MeshCentral/rdp/protocol/rdp.js

/*
 * Copyright (c) 2014-2015 Sylvain Peyrefitte
 *
 * This file is part of node-rdpjs.
 *
 * node-rdpjs is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

var net = require('net');
var inherits = require('util').inherits;
var events = require('events');
var layer = require('../core').layer;
var error = require('../core').error;
var rle = require('../core').rle;
var log = require('../core').log;
var TPKT = require('./tpkt');
var x224 = require('./x224');
var t125 = require('./t125');
var pdu = require('./pdu');

/**
 * decompress bitmap from RLE algorithm
 * @param	bitmap	{object} bitmap object of bitmap event of node-rdpjs
 */
function decompress (bitmap) {
	var fName = null;
	switch (bitmap.bitsPerPixel.value) {
	case 15:
		fName = 'bitmap_decompress_15';
		break;
	case 16:
		fName = 'bitmap_decompress_16';
		break;
	case 24:
		fName = 'bitmap_decompress_24';
		break;
	case 32:
		fName = 'bitmap_decompress_32';
		break;
	default:
		throw 'invalid bitmap data format';
	}
	
	var input = new Uint8Array(bitmap.bitmapDataStream.value);
	var inputPtr = rle._malloc(input.length);
	var inputHeap = new Uint8Array(rle.HEAPU8.buffer, inputPtr, input.length);
	inputHeap.set(input);
	
	var ouputSize = bitmap.width.value * bitmap.height.value * 4;
	var outputPtr = rle._malloc(ouputSize);

	var outputHeap = new Uint8Array(rle.HEAPU8.buffer, outputPtr, ouputSize);

	var res = rle.ccall(fName,
		'number',
		['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number'],
		[outputHeap.byteOffset, bitmap.width.value, bitmap.height.value, bitmap.width.value, bitmap.height.value, inputHeap.byteOffset, input.length]
	);
	
	var output = new Uint8ClampedArray(outputHeap.buffer, outputHeap.byteOffset, ouputSize);
	
	rle._free(inputPtr);
	rle._free(outputPtr);
	
	return output;
}

/**
 * Main RDP module
 */
function RdpClient(config) {
	config = config || {};
	this.connected = false;
	this.bufferLayer = new layer.BufferLayer(new net.Socket());
	this.tpkt = new TPKT(this.bufferLayer);
	this.x224 = new x224.Client(this.tpkt, config);
	this.mcs = new t125.mcs.Client(this.x224);
	this.sec = new pdu.sec.Client(this.mcs, this.tpkt);
	this.global = new pdu.global.Client(this.sec, this.sec);
	
	// config log level
	log.level = log.Levels[config.logLevel || 'INFO'] || log.Levels.INFO;
	
	// credentials
	if (config.domain) {
		this.sec.infos.obj.domain.value = Buffer.from(config.domain + '\x00', 'ucs2');
	}
	if (config.userName) {
		this.sec.infos.obj.userName.value = Buffer.from(config.userName + '\x00', 'ucs2');
	}
	if (config.password) {
		this.sec.infos.obj.password.value = Buffer.from(config.password + '\x00', 'ucs2');
	}
	if(config.workingDir) {
		this.sec.infos.obj.workingDir.value = Buffer.from(config.workingDir + '\x00', 'ucs2');
	}
	if(config.alternateShell) {
		this.sec.infos.obj.alternateShell.value = Buffer.from(config.alternateShell + '\x00', 'ucs2');
	}
	
	if (config.enablePerf) {
		this.sec.infos.obj.extendedInfo.obj.performanceFlags.value = 
				pdu.sec.PerfFlag.PERF_DISABLE_WALLPAPER 
			| 	pdu.sec.PerfFlag.PERF_DISABLE_MENUANIMATIONS 
			| 	pdu.sec.PerfFlag.PERF_DISABLE_CURSOR_SHADOW 
			| 	pdu.sec.PerfFlag.PERF_DISABLE_THEMING 
			| 	pdu.sec.PerfFlag.PERF_DISABLE_FULLWINDOWDRAG;
	}
	
	if (config.autoLogin) {
		this.sec.infos.obj.flag.value |= pdu.sec.InfoFlag.INFO_AUTOLOGON;
	}
	
	if (config.screen && config.screen.width && config.screen.height) {
		this.mcs.clientCoreData.obj.desktopWidth.value = config.screen.width;
		this.mcs.clientCoreData.obj.desktopHeight.value = config.screen.height;
	}
	
	log.debug('screen ' + this.mcs.clientCoreData.obj.desktopWidth.value + 'x' + this.mcs.clientCoreData.obj.desktopHeight.value);
	
	// config keyboard layout
	switch (config.locale) {
	case 'fr':
		log.debug('french keyboard layout');
		this.mcs.clientCoreData.obj.kbdLayout.value = t125.gcc.KeyboardLayout.FRENCH;
		break;
	case 'en':
	default:
		log.debug('english keyboard layout');
		this.mcs.clientCoreData.obj.kbdLayout.value = t125.gcc.KeyboardLayout.US;
	}
		
	
	//bind all events
	var self = this;
	this.global.on('connect', function () {
		self.connected = true;
		self.emit('connect');
	}).on('session', function () {
		self.emit('session');
	}).on('close', function () {
		self.connected = false;
		self.emit('close');
	}).on('bitmap', function (bitmaps) {
		for(var bitmap in bitmaps) {
			var bitmapData = bitmaps[bitmap].obj.bitmapDataStream.value;
			var isCompress = bitmaps[bitmap].obj.flags.value & pdu.data.BitmapFlag.BITMAP_COMPRESSION;
			
			if (isCompress && config.decompress) {
				bitmapData = decompress(bitmaps[bitmap].obj);
				isCompress = false;
			}
			
			self.emit('bitmap', { 
				destTop : bitmaps[bitmap].obj.destTop.value,
				destLeft : bitmaps[bitmap].obj.destLeft.value, 
				destBottom : bitmaps[bitmap].obj.destBottom.value, 
				destRight : bitmaps[bitmap].obj.destRight.value, 
				width : bitmaps[bitmap].obj.width.value,
				height : bitmaps[bitmap].obj.height.value,
				bitsPerPixel : bitmaps[bitmap].obj.bitsPerPixel.value,
				isCompress : isCompress,
				data : bitmapData
			});
		}
	}).on('error', function (err) {
		log.warn(err.code + '(' + err.message + ')\n' + err.stack);
		if (err instanceof error.FatalError) {
			throw err;
		}
		else {
			self.emit('error', err);
		}
	});
}

inherits(RdpClient, events.EventEmitter);

/**
 * Connect RDP client
 * @param host {string} destination host
 * @param port {integer} destination port
 */
RdpClient.prototype.connect = function (host, port) {
	log.debug('connect to ' + host + ':' + port);
	var self = this;
	this.bufferLayer.socket.connect(port, host, function () {
		// in client mode connection start from x224 layer
		self.x224.connect();
	});
	return this;
};

/**
 * Close RDP client
 */
RdpClient.prototype.close = function () {
	if(this.connected) {
		this.global.close();
	}
	this.connected = false;
	return this;
};

/**
 * Send pointer event to server
 * @param x {integer} mouse x position
 * @param y {integer} mouse y position
 * @param button {integer} button number of mouse
 * @param isPressed {boolean} state of button
 */
RdpClient.prototype.sendPointerEvent = function (x, y, button, isPressed) {
	if (!this.connected)
		return;
	
	var event = pdu.data.pointerEvent();
	if (isPressed) {
		event.obj.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_DOWN;
	}
	
	switch(button) {
	case 1:
		event.obj.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_BUTTON1;
		break;
	case 2:
		event.obj.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_BUTTON2;
		break;
	case 3:
		event.obj.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_BUTTON3
		break;
	default:
		event.obj.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_MOVE;
	}
	
    event.obj.xPos.value = x;
    event.obj.yPos.value = y;
    
    this.global.sendInputEvents([event]);
};

/**
 * send scancode event
 * @param code {integer}
 * @param isPressed {boolean}
 * @param extended {boolenan} extended keys
 */
RdpClient.prototype.sendKeyEventScancode = function (code, isPressed, extended) {
	if (!this.connected)
		return;
	extended = extended || false;
	var event = pdu.data.scancodeKeyEvent();
	event.obj.keyCode.value = code;
	
	if (!isPressed) {
		event.obj.keyboardFlags.value |= pdu.data.KeyboardFlag.KBDFLAGS_RELEASE;
	}
    
    if (extended) {
    	event.obj.keyboardFlags.value |= pdu.data.KeyboardFlag.KBDFLAGS_EXTENDED;
    }
    
    this.global.sendInputEvents([event]);
};

/**
 * Send key event as unicode
 * @param code {integer}
 * @param isPressed {boolean}
 */
RdpClient.prototype.sendKeyEventUnicode = function (code, isPressed) {
	if (!this.connected)
		return;
	
	var event = pdu.data.unicodeKeyEvent();
	event.obj.unicode.value = code;
	
	if (!isPressed) {
		event.obj.keyboardFlags.value |= pdu.data.KeyboardFlag.KBDFLAGS_RELEASE;
	}
	this.global.sendInputEvents([event]);
}

/**
 * Wheel mouse event
 * @param x {integer} mouse x position
 * @param y {integer} mouse y position
 * @param step {integer} wheel step
 * @param isNegative {boolean}
 * @param isHorizontal {boolean}
 */
RdpClient.prototype.sendWheelEvent = function (x, y, step, isNegative, isHorizontal) {
	if (!this.connected)
		return;
	
	var event = pdu.data.pointerEvent();
	if (isHorizontal) {
        event.obj.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_HWHEEL;
	}
    else {
    	event.obj.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_WHEEL;
    }
        
	
	if (isNegative) {
        event.obj.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_WHEEL_NEGATIVE;
	}
        
    event.obj.pointerFlags.value |= (step & pdu.data.PointerFlag.WheelRotationMask)
	
    event.obj.xPos.value = x;
    event.obj.yPos.value = y;
    
    this.global.sendInputEvents([event]);
}

function createClient(config) {
	return new RdpClient(config);
};

/**
 * RDP server side protocol
 * @param config {object} configuration
 * @param socket {net.Socket}
 */
function RdpServer(config, socket) {
	if (!(config.key && config.cert)) {
		throw new error.FatalError('NODE_RDP_PROTOCOL_RDP_SERVER_CONFIG_MISSING', 'missing cryptographic tools')
	}
	this.connected = false;
	this.bufferLayer = new layer.BufferLayer(socket);
	this.tpkt = new TPKT(this.bufferLayer);
	this.x224 = new x224.Server(this.tpkt, config.key, config.cert);
	this.mcs = new t125.mcs.Server(this.x224);
};

inherits(RdpServer, events.EventEmitter);

function createServer (config, next) {
	return net.createServer(function (socket) {
		next(new RdpServer(config, socket));
	});
};

/**
 * Module exports
 */
module.exports = {
		createClient : createClient,
		createServer : createServer
};