MeshCentral/rdp/core/layer.js

230 lines
5.5 KiB
JavaScript

/*
* 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 inherits = require('util').inherits;
var fs = require('fs');
var type = require('./type');
var log = require('./log');
var tls = require('tls');
//var crypto = require('crypto');
var events = require('events');
/**
* Buffer data from socket to present
* well formed packets
*/
function BufferLayer(socket) {
//for ssl connection
this.secureSocket = null;
this.socket = socket;
var self = this;
// bind event
this.socket.on('data', function(data) {
try {
self.recv(data);
}
catch(e) {
self.socket.destroy();
self.emit('error', e);
}
}).on('close', function() {
self.emit('close');
}).on('error', function (err) {
self.emit('error', err);
});
//buffer data
this.buffers = [];
this.bufferLength = 0;
//expected size
this.expectedSize = 0;
}
inherits(BufferLayer, events.EventEmitter);
/**
* Call from tcp layer
* @param data tcp stream
*/
BufferLayer.prototype.recv = function (data) {
if (this.buffers.length == 0) { this.bufferLength = 0; } // CORRECT
this.buffers[this.buffers.length] = data;
this.bufferLength += data.length;
//console.log('TCP RECV', this.bufferLength, this.expectedSize, data.toString('hex'));
//console.log('this.buffers', this.buffers);
//console.log('this.expectedSize', this.expectedSize);
//console.log('this.bufferLength', this.bufferLength);
if (this.expectedSize == 0) { console.log('this.expectedSize == 0'); return; }
while (this.bufferLength >= this.expectedSize) {
//console.log('this.expectedSize', this.expectedSize);
//console.log('this.bufferLength', this.bufferLength);
//linear buffer
var expectedData = new type.Stream(this.expectedSize);
//create expected data
while (expectedData.availableLength() > 0) {
var rest = expectedData.availableLength();
var buffer = this.buffers.shift();
//console.log('xx', rest, buffer);
if (buffer.length > expectedData.availableLength()) {
this.buffers.unshift(buffer.slice(rest));
new type.BinaryString(buffer, { readLength : new type.CallableValue(expectedData.availableLength()) }).write(expectedData);
} else {
new type.BinaryString(buffer).write(expectedData);
}
}
this.bufferLength -= this.expectedSize;
expectedData.offset = 0;
//console.log('TCP EMIT', expectedData);
this.emit('data', expectedData);
}
};
/**
* Call tcp socket to write stream
* @param {type.Type} packet
*/
BufferLayer.prototype.send = function(data) {
var s = new type.Stream(data.size());
data.write(s);
if(this.secureSocket) {
this.secureSocket.write(s.buffer);
}
else {
this.socket.write(s.buffer);
}
};
/**
* Call tcp socket to write a buffer
*/
BufferLayer.prototype.sendBuffer = function (buffer) {
if (this.secureSocket) {
//console.log('SSL sendBuffer', buffer.length, buffer.toString('hex'));
this.secureSocket.write(buffer);
}
else {
//console.log('TCP sendBuffer', buffer.length, buffer.toString('hex'));
this.socket.write(buffer);
}
};
/**
* Wait expected size data before call callback function
* @param {number} expectSize size expected
*/
BufferLayer.prototype.expect = function(expectedSize) {
this.expectedSize = expectedSize;
};
/**
* Convert connection to TLS connection
* @param callback {func} when connection is done
*/
BufferLayer.prototype.startTLS = function(callback) {
var self = this;
this.secureSocket = tls.connect({
socket: this.socket,
secureContext: tls.createSecureContext(),
isServer: false,
requestCert: false,
rejectUnauthorized: false
}, (err) => {
log.warn(err);
callback(err);
});
this.secureSocket.on('data', function (data) {
//console.log('SSL RECV', data.length, data);
try {
self.recv(data);
}
catch (e) {
//console.log('SSL RECV ERR', e);
self.socket.destroy();
self.emit('error', e);
}
}).on('error', function (err) {
self.emit('error', err);
});
};
/**
* Convert connection to TLS server
* @param keyFilePath {string} key file path
* @param crtFilePath {string} certificat file path
* @param callback {function}
*/
BufferLayer.prototype.listenTLS = function(keyFilePath, crtFilePath, callback) {
var self = this;
this.secureSocket = tls.connect({
socket: this.socket,
secureContext: tls.createSecureContext({
key: fs.readFileSync(keyFilePath),
cert: fs.readFileSync(crtFilePath),
}),
isServer: true,
requestCert: false,
rejectUnauthorized: false
}, (err) => {
log.warn(err);
callback(err);
});
this.secureSocket.on('data', function(data) {
try {
self.recv(data);
}
catch(e) {
self.socket.destroy();
self.emit('error', e);
}
}).on('error', function (err) {
self.emit('error', err);
});
};
/**
* close stack
*/
BufferLayer.prototype.close = function() {
this.socket.end();
};
/**
* Module exports
*/
module.exports = {
BufferLayer : BufferLayer
};