404 lines
15 KiB
JavaScript
404 lines
15 KiB
JavaScript
'use strict';
|
|
|
|
const fs = require('fs');
|
|
const http = require('http');
|
|
const https = require('https');
|
|
const strftime = require('strftime');
|
|
const net = require('net');
|
|
const CryptoJS = require('crypto-js');
|
|
const mime = require('mime-types');
|
|
var str2ab = require('string-to-arraybuffer')
|
|
var WTVNetworkSecurity = require('./wtvsec.js');
|
|
|
|
var zdebug = true;
|
|
var secure_mode = true;
|
|
|
|
var pubip = "192.168.11.8";
|
|
var port = 1615;
|
|
|
|
var sec_session = new Array();
|
|
var socket_session_data = new Array();
|
|
|
|
function getPublicIP() {
|
|
var options = {
|
|
host: 'www.planeptune.org',
|
|
path: '/ip.php'
|
|
}
|
|
var request = https.get(options, function (res) {
|
|
var data = '';
|
|
res.on('data', function (chunk) {
|
|
data += chunk;
|
|
});
|
|
res.on('end', function () {
|
|
return data;
|
|
});
|
|
});
|
|
}
|
|
|
|
function doErrorPage(code) {
|
|
var headers, data = null;
|
|
switch (code) {
|
|
case 404:
|
|
data = "The resource you requested could not be found.";
|
|
headers = "HTTP/1.1 404 Not Found\r\n";
|
|
headers += "Content-Type: text/html\r\n";
|
|
break;
|
|
case 400:
|
|
data = "An internal server error has occured.";
|
|
headers = "400 HackTV ran into a technical problem.\r\n";
|
|
headers += "Content-Type: text/html\r\n";
|
|
break;
|
|
default:
|
|
// what we send when we did not detect a wtv-url.
|
|
// e.g. when a pc browser connects
|
|
data = "Hello, stranger!";
|
|
headers = "HTTP/1.1 200 OK\r\n";
|
|
headers += "Content-Type: text/html\r\n";
|
|
break;
|
|
}
|
|
return new Array(headers, data);
|
|
}
|
|
|
|
function processPath(socket, path, initial_headers = new Array(), query = new Array()) {
|
|
var headers, data = null;
|
|
var request_is_direct_file = false;
|
|
try {
|
|
try {
|
|
// try to see if the exact request exists
|
|
if (fs.lstatSync(path).isFile()) {
|
|
request_is_direct_file = true;
|
|
}
|
|
} catch (e) {
|
|
// do nothing its fine
|
|
}
|
|
|
|
if (request_is_direct_file) {
|
|
// file exists, read it and return it
|
|
console.log(" * Found " + path + " to handle request (Direct File Mode)");
|
|
var contype = mime.lookup(path);
|
|
data = fs.readFileSync(path).buffer;
|
|
headers = "200 OK\n"
|
|
headers += "Content-Type: " + contype;
|
|
} else if (fs.existsSync(path + ".txt")) {
|
|
// raw text format, entire payload expected (headers and content)
|
|
console.log(" * Found " + path + ".txt to handle request (Raw TXT Mode)");
|
|
var fdat = fs.readFileSync(path + ".txt").toString();
|
|
headers = fdat.split("\n\n")[0];
|
|
data = fdat.split("\n\n")[1];
|
|
} else if (fs.existsSync(path + ".js")) {
|
|
// js scripting, process with vars, must set 'headers' and 'data' appropriately.
|
|
// loaded script will have r/w access to any JavaScript vars this function does.
|
|
// any query args are in an array named 'query'
|
|
console.log(" * Found " + path + ".js to handle request (JS Interpreter mode)");
|
|
var fdat = fs.readFileSync(path + ".js").toString();
|
|
eval(fdat);
|
|
} else if (fs.existsSync(path + ".html")) {
|
|
// Standard HTML with no headers, WTV Style
|
|
console.log(" * Found " + path + ".html to handle request (HTML Mode)");
|
|
data = fs.readFileSync(path + ".html").toString();
|
|
headers = "200 OK\n"
|
|
headers += "Content-Type: text/html"
|
|
} else {
|
|
var errpage = doErrorPage(404);
|
|
headers = errpage[0];
|
|
data = errpage[1];
|
|
}
|
|
|
|
// 'headers' and 'data' should both be set with content by this point!
|
|
|
|
|
|
if (headers != null) {
|
|
if (typeof headers !== "string") {
|
|
headers = headers.toString();
|
|
}
|
|
} else {
|
|
var errpage = doErrorPage(400);
|
|
headers = errpage[0];
|
|
data = errpage[1];
|
|
}
|
|
if (data === null) {
|
|
data = '';
|
|
}
|
|
} catch (e) {
|
|
var errpage = doErrorPage(400);
|
|
headers = errpage[0];
|
|
data = errpage[1] + "<br><br>The interpreter said:<br><pre>" + e.toString() + "</pre>";
|
|
console.log(e);
|
|
}
|
|
if (headers.toLowerCase().indexOf("content-length") === -1) {
|
|
if (typeof data.length !== 'undefined') {
|
|
headers += "\nContent-Length: " + data.length;
|
|
} else if (typeof data.byteLength !== 'undefined') {
|
|
headers += "\nContent-Length: " + data.byteLength;
|
|
}
|
|
}
|
|
return new Array(headers, data);
|
|
}
|
|
|
|
function processURL(socket, initial_headers) {
|
|
if (initial_headers === null) {
|
|
return;
|
|
}
|
|
var shortURL, headers, data = "";
|
|
var query = new Array();
|
|
if (initial_headers['request_url']) {
|
|
if (initial_headers['request_url'].indexOf('?') >= 0) {
|
|
shortURL = initial_headers['request_url'].split('?')[0];
|
|
var qraw = initial_headers['request_url'].split('?')[1];
|
|
if (qraw.length > 0) {
|
|
qraw = qraw.split("&");
|
|
for (let i = 0; i < qraw.length; i++) {
|
|
query[qraw[i].split("=")[0]] = qraw[i].split("=")[1];
|
|
}
|
|
if (zdebug) {
|
|
console.log("URL Request has query arguments:")
|
|
console.log(query);
|
|
}
|
|
}
|
|
} else {
|
|
shortURL = initial_headers['request_url'];
|
|
}
|
|
|
|
if (shortURL.indexOf(':/') >= 0) {
|
|
var ssid = socket_session_data[socket.id].ssid;
|
|
if (ssid == null) {
|
|
ssid = initial_headers['wtv-client-serial-number'];
|
|
}
|
|
if (ssid != null) {
|
|
console.log(" * Request for " + initial_headers['request_url'] + " from WebTV SSID " + ssid);
|
|
} else {
|
|
console.log(" * Request for " + initial_headers['request_url']);
|
|
}
|
|
// assume webtv since there is a :/ in the GET
|
|
var urlToPath = __dirname + "/ServiceVault/" + shortURL.split(':/')[0] + "/" + shortURL.split(':/')[1];
|
|
if (zdebug) console.log(initial_headers);
|
|
var result = processPath(socket, urlToPath, initial_headers, query);
|
|
|
|
if (result[0] == null) {
|
|
var errpage = doErrorPage(404);
|
|
headers = errpage[0];
|
|
data = errpage[1];
|
|
} else {
|
|
headers = result[0];
|
|
data = result[1];
|
|
}
|
|
} else {
|
|
switch (shortURL) {
|
|
default:
|
|
var errpage = doErrorPage(200);
|
|
headers = errpage[0];
|
|
data = errpage[1];
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
var errpage = doErrorPage(400);
|
|
headers = errpage[0];
|
|
data = errpage[1];
|
|
}
|
|
|
|
// headers to object
|
|
if (typeof headers != 'object') {
|
|
var headers_obj = {};
|
|
var inc_headers = 1;
|
|
headers.split('\n').forEach(function (d) {
|
|
if (d.length > 0) {
|
|
if (d.indexOf(":") > 0 && !/^([0-9]{3} )/.test(d.substring(0, 4))) {
|
|
var d = d.split(':');
|
|
var header_name = d[0];
|
|
d.shift();
|
|
if (headers_obj[header_name] != null) {
|
|
header_name = header_name + "_" + inc_headers;
|
|
inc_headers++;
|
|
}
|
|
headers_obj[header_name] = d.join(':').replace("\r", "");
|
|
if (headers_obj[header_name].substring(0, 1) == " ") {
|
|
headers_obj[header_name] = headers_obj[header_name].substring(1);
|
|
}
|
|
} else if (/^([0-9]{3} )/.test(d.substring(0, 4))) {
|
|
headers_obj['http_response'] = d.replace("\r", "");
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
header_obj = headers;
|
|
}
|
|
|
|
// set wtv-encrypted and put it near the top of the headers (unknown if needed)
|
|
if (socket_session_data[socket.id].secure == true) {
|
|
console.log(" * encrypting response to client ...")
|
|
headers_obj['wtv-encrypted'] = true;
|
|
headers_obj = moveObjectElement('wtv-encrypted', 'Connection', headers_obj);
|
|
var enc_data = sec_session[socket_session_data[socket.id].ssid].EncryptKey2(data);
|
|
var test = data;
|
|
}
|
|
|
|
headers = "";
|
|
console.log(headers_obj);
|
|
Object.keys(headers_obj).forEach(function (k) {
|
|
if (k == "http_response") {
|
|
headers += headers_obj[k] + "\r\n";
|
|
} else {
|
|
if (k.indexOf('_') >= 0) {
|
|
var j = k.split('_')[0];
|
|
headers += j + ": " + headers_obj[k] + "\n";
|
|
} else {
|
|
headers += k + ": " + headers_obj[k] + "\n";
|
|
}
|
|
}
|
|
});
|
|
var toClient = null;
|
|
if (typeof data == 'string') {
|
|
toClient = headers + "\n" + data;
|
|
socket.write(toClient);
|
|
} else if (typeof data == 'object') {
|
|
socket.write(new Uint8Array(concatArrayBuffer(Buffer.from(headers + "\r\n"), data)));
|
|
}
|
|
if (headers_obj['Connection']) {
|
|
if (headers_obj['Connection'].toLowerCase() == "close") {
|
|
socket.destroy();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
function concatArrayBuffer(buffer1, buffer2) {
|
|
var tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength);
|
|
tmp.set(new Uint8Array(buffer1), 0);
|
|
tmp.set(new Uint8Array(buffer2), buffer1.byteLength);
|
|
return tmp.buffer;
|
|
}
|
|
|
|
function moveObjectElement(currentKey, afterKey, obj) {
|
|
var result = {};
|
|
var val = obj[currentKey];
|
|
delete obj[currentKey];
|
|
var next = -1;
|
|
var i = 0;
|
|
if (typeof afterKey == 'undefined' || afterKey == null) afterKey = '';
|
|
Object.keys(obj).forEach(function (k) {
|
|
var v = obj[k];
|
|
if ((afterKey == '' && i == 0) || next == 1) {
|
|
result[currentKey] = val;
|
|
next = 0;
|
|
}
|
|
if (k == afterKey) { next = 1; }
|
|
result[k] = v;
|
|
++i;
|
|
});
|
|
if (next == 1) {
|
|
result[currentKey] = val;
|
|
}
|
|
if (next !== -1) return result; else return obj;
|
|
}
|
|
|
|
function headersAreStandard(string) {
|
|
// the test will see the binary compressed/enrypted data as ASCII, so a generic "isAscii"
|
|
// is not suffuicent. This checks for characters expected in unecrypted headers, and returns
|
|
// true only if every character in the string matches the regex. Once we know the string is binary
|
|
// we can better process it with the raw base64 data in processHeaders() below.
|
|
var test = /^([A-Za-z0-9\+\/\=\-\.\ \;\:\?\&\r\n\(\)\%\<\>\_]{8,})$/.test(string);
|
|
if (zdebug) console.log("request is ascii: " + test);
|
|
if (zdebug) console.log("request as follows: " + string);
|
|
return test;
|
|
}
|
|
|
|
function processHeaders(socket, data_b64, returnHeadersBeforeSecure = false) {
|
|
var url = "";
|
|
var data = CryptoJS.enc.Latin1.stringify(CryptoJS.enc.Base64.parse(data_b64));
|
|
|
|
var headers = new Array();
|
|
if (typeof data === "string") {
|
|
if (data.length > 1) {
|
|
if (headersAreStandard(data)) {
|
|
data = data.split("\r\n\r\n")[0];
|
|
data.split('\n').forEach(function (d) {
|
|
if (d.length > 0) {
|
|
if (/^SECURE ON/.test(d)) {
|
|
console.log(data);
|
|
secure_mode = true;
|
|
headers['secure'] = true;
|
|
socket_session_data[socket.id].secure = true;
|
|
}
|
|
if (d.indexOf(":") > 0 && d.indexOf(":/") == -1) {
|
|
headers[d.split(':')[0]] = (d.split(':')[1]).replace("\r", "");
|
|
if (headers[d.split(':')[0]].substring(0, 1) == " ") {
|
|
headers[d.split(':')[0]] = headers[d.split(':')[0]].substring(1);
|
|
}
|
|
} else if (/^(GET |PUT |POST)$/.test(d.substring(0, 4))) {
|
|
headers['request'] = d.replace("\r", "");
|
|
headers['request_url'] = (d.split(' ')[1]).replace("\r", "");
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
// failed the headersAreStandard test, so we think this is a binary blob
|
|
var encdata = CryptoJS.enc.Base64.parse(data_b64);
|
|
var decdata = sec_session[socket_session_data[socket.id].ssid].DecryptKey1(encdata);
|
|
var test = decdata;
|
|
}
|
|
if (headers['wtv-client-rom-type'] != null) {
|
|
socket_session_data[socket.id].romtype = headers['wtv-client-rom-type'];
|
|
}
|
|
if (headers['wtv-client-serial-number'] != null) {
|
|
socket_session_data[socket.id].ssid = headers['wtv-client-serial-number'];
|
|
}
|
|
if (headers['wtv-incarnation'] != null) {
|
|
if (sec_session[socket_session_data[socket.id].ssid]) {
|
|
sec_session[socket_session_data[socket.id].ssid].set_incarnation(headers['wtv-incarnation']);
|
|
}
|
|
}
|
|
|
|
if (returnHeadersBeforeSecure) {
|
|
return headers;
|
|
}
|
|
|
|
if (headers['secure'] === true) {
|
|
// assume we have an ssid if we are this far
|
|
sec_session[headers['wtv-client-serial-number']].SecureOn();
|
|
if (!headers['request_url']) {
|
|
var header_length = data.length + 4;
|
|
var enc_data = CryptoJS.enc.Hex.parse(CryptoJS.enc.Base64.parse(data_b64).toString(CryptoJS.enc.Hex).substring(header_length * 2));
|
|
console.log(enc_data.toString(CryptoJS.enc.Hex));
|
|
if (enc_data.sigBytes > 0) {
|
|
var dec_data = sec_session[socket_session_data[socket.id].ssid].DecryptKey1(enc_data);
|
|
console.log(dec_data);
|
|
console.log(headers);
|
|
}
|
|
}
|
|
}
|
|
return headers;
|
|
} else {
|
|
// socket error, terminate it.
|
|
socket.destroy();
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
var server = net.createServer(function (socket) {
|
|
socket.binaryType = 'arraybuffer';
|
|
socket.id = Math.floor(Math.random() * 1000);
|
|
socket_session_data[socket.id] = [];
|
|
socket.setEncoding('base64'); //set data encoding (either 'ascii', 'utf8', or 'base64')
|
|
|
|
socket.on('data', function (data_b64) {
|
|
processURL(this, processHeaders(this, data_b64));
|
|
});
|
|
|
|
socket.on('error', (err, socket) => {
|
|
console.log('client socket error:', err);
|
|
});
|
|
|
|
socket.on('end', function () {
|
|
secure_mode = false;
|
|
socket_session_data[socket.id] = null;
|
|
});
|
|
});
|
|
|
|
server.listen(port, '0.0.0.0');
|
|
process.stdout.write("Looking up public IP address... ");
|
|
//pubip = getPublicIP();
|
|
console.log(pubip + " ...");
|
|
|
|
console.log('Listening on port ' + port + ' for WebTV Units in Scriptless Mode'); |