234 lines
6.7 KiB
JavaScript
234 lines
6.7 KiB
JavaScript
const http = require('http');
|
|
const URL = require('url');
|
|
const { Server } = http;
|
|
|
|
const Promise = require('bluebird');
|
|
const socks = require('socksv5');
|
|
|
|
const TOR_ROUTER_PROXY_AGENT = 'tor-router';
|
|
|
|
class HTTPServer extends Server {
|
|
async listen() {
|
|
return await new Promise((resolve, reject) => {
|
|
let args = Array.from(arguments);
|
|
let inner_func = super.listen;
|
|
args.push(() => {
|
|
let args = Array.from(arguments);
|
|
resolve.apply(args);
|
|
});
|
|
inner_func.apply(this, args);
|
|
});
|
|
}
|
|
|
|
authenticate_user_http(req, res) {
|
|
return this.authenticate_user(req, () => {
|
|
res.writeHead(407, { 'Proxy-Authenticate': `Basic realm="Name of instance to route to"` });
|
|
res.end();
|
|
return false;
|
|
})
|
|
}
|
|
|
|
authenticate_user_connect(req, socket) {
|
|
return this.authenticate_user(req, () => {
|
|
socket.end();
|
|
return false;
|
|
})
|
|
}
|
|
|
|
authenticate_user(req, deny) {
|
|
if (!this.proxy_by_name)
|
|
return true;
|
|
|
|
let deny_un = this.proxy_by_name.deny_unidentified_users;
|
|
|
|
let header = req.headers['authorization'] || req.headers['proxy-authorization'];
|
|
if (!header && deny_un) return deny();
|
|
else if (!header) return true;
|
|
|
|
let token = header.split(/\s+/).pop();
|
|
if (!token && deny_un) return deny();
|
|
else if (!token) return true;
|
|
|
|
let buf = new Buffer.from(token, 'base64').toString();
|
|
let username = buf.split(/:/).shift();
|
|
if ( !username && deny_un ) return deny();
|
|
else if (!username) return true;
|
|
|
|
this.logger.verbose(`[http]: connected attempted to instance "${username}"`);
|
|
|
|
let instance = this.tor_pool.instance_by_name(username);
|
|
|
|
if (!instance) return deny();
|
|
req.instance = instance;
|
|
|
|
return true;
|
|
}
|
|
|
|
constructor(tor_pool, logger, proxy_by_name) {
|
|
let handle_http_connections = (req, res) => {
|
|
if (!this.authenticate_user_http(req, res))
|
|
return;
|
|
|
|
let { instance } = req;
|
|
|
|
let url = URL.parse(req.url);
|
|
url.port = url.port || 80;
|
|
|
|
let buffer = [];
|
|
|
|
function onIncomingData(chunk) {
|
|
buffer.push(chunk);
|
|
}
|
|
|
|
function preConnectClosed() {
|
|
req.finished = true;
|
|
}
|
|
|
|
req.on('data', onIncomingData);
|
|
req.on('end', preConnectClosed);
|
|
req.on('error', function (err) {
|
|
this.logger.error("[http-proxy]: an error occured: "+err.message);
|
|
});
|
|
|
|
let connect = (tor_instance) => {
|
|
let source = { hostname: req.connection.remoteAddress, port: req.connection.remotePort, proto: 'http', by_name: Boolean(instance) };
|
|
this.emit('instance-connection', tor_instance, source);
|
|
let socks_port = tor_instance.socks_port;
|
|
this.logger.verbose(`[http-proxy]: ${source.hostname}:${source.port} → 127.0.0.1:${socks_port}${tor_instance.definition.Name ? ' ('+tor_instance.definition.Name+')' : '' } → ${url.hostname}:${url.port}`);
|
|
|
|
let proxy_req = http.request({
|
|
method: req.method,
|
|
hostname: url.hostname,
|
|
port: url.port,
|
|
path: url.path,
|
|
headers: req.headers,
|
|
agent: socks.HttpAgent({
|
|
proxyHost: '127.0.0.1',
|
|
proxyPort: socks_port,
|
|
auths: [ socks.auth.None() ],
|
|
localDNS: false
|
|
})
|
|
}, (proxy_res) => {
|
|
proxy_res.on('data', (chunk) => {
|
|
res.write(chunk);
|
|
});
|
|
|
|
proxy_res.on('end', () => {
|
|
res.end();
|
|
});
|
|
|
|
res.writeHead(proxy_res.statusCode, proxy_res.headers);
|
|
});
|
|
|
|
req.removeListener('data', onIncomingData);
|
|
|
|
req.on('data', (chunk) => {
|
|
proxy_req.write(chunk);
|
|
})
|
|
|
|
req.on('end', () => {
|
|
proxy_req.end();
|
|
})
|
|
|
|
while (buffer.length) {
|
|
proxy_req.write(buffer.shift());
|
|
}
|
|
|
|
if (req.finished)
|
|
proxy_req.end();
|
|
|
|
};
|
|
|
|
if (instance) {
|
|
if (instance.ready) {
|
|
connect(instance);
|
|
}
|
|
else {
|
|
this.logger.debug(`[socks]: a connection has been attempted to "${instance.instance_name}", but it is not live... waiting for the instance to come online`);
|
|
instance.once('ready', (() => connect(instance)));
|
|
}
|
|
}
|
|
else if (this.tor_pool.instances.length) {
|
|
connect(tor_pool.next());
|
|
} else {
|
|
this.logger.debug(`[http-proxy]: a connection has been attempted, but no tor instances are live... waiting for an instance to come online`);
|
|
tor_pool.once('instance_created', connect);
|
|
}
|
|
};
|
|
|
|
let handle_connect_connections = (req, inbound_socket, head) => {
|
|
if (!this.authenticate_user_connect(req, inbound_socket))
|
|
return;
|
|
|
|
let { instance } = req;
|
|
|
|
let hostname = req.url.split(':').shift();
|
|
let port = Number(req.url.split(':').pop());
|
|
|
|
let connect = (tor_instance) => {
|
|
let source = { hostname: req.connection.remoteAddress, port: req.connection.remotePort, proto: 'http-connect', by_name: Boolean(instance) };
|
|
this.emit('instance-connection', tor_instance, source);
|
|
let socks_port = tor_instance.socks_port;
|
|
this.logger && this.logger.verbose(`[http-connect]: ${source.hostname}:${source.port} → 127.0.0.1:${socks_port}${tor_instance.definition.Name ? ' ('+tor_instance.definition.Name+')' : '' } → ${hostname}:${port}`)
|
|
var outbound_socket;
|
|
|
|
let onClose = (error) => {
|
|
inbound_socket && inbound_socket.end();
|
|
outbound_socket && outbound_socket.end();
|
|
|
|
inbound_socket = outbound_socket = void(0);
|
|
|
|
if (error instanceof Error)
|
|
this.logger.error(`[http-connect]: an error occured: ${error.message}`)
|
|
};
|
|
|
|
inbound_socket.on('error', onClose);
|
|
inbound_socket.on('close', onClose);
|
|
|
|
socks.connect({
|
|
host: hostname,
|
|
port: port,
|
|
proxyHost: '127.0.0.1',
|
|
proxyPort: socks_port,
|
|
localDNS: false,
|
|
auths: [ socks.auth.None() ]
|
|
}, ($outbound_socket) => {
|
|
outbound_socket = $outbound_socket;
|
|
outbound_socket.on('close', onClose);
|
|
outbound_socket.on('error', onClose);
|
|
|
|
inbound_socket.write(`HTTP/1.1 200 Connection Established\r\n'+'Proxy-agent: ${TOR_ROUTER_PROXY_AGENT}\r\n` +'\r\n');
|
|
outbound_socket.write(head);
|
|
|
|
outbound_socket.pipe(inbound_socket);
|
|
inbound_socket.pipe(outbound_socket);
|
|
});
|
|
};
|
|
|
|
if (instance) {
|
|
if (instance.ready) {
|
|
connect(instance);
|
|
}
|
|
else {
|
|
this.logger.debug(`[socks]: a connection has been attempted to "${instance.instance_name}", but it is not live... waiting for the instance to come online`);
|
|
instance.once('ready', (() => connect(instance)));
|
|
}
|
|
}
|
|
else if (this.tor_pool.instances.length) {
|
|
connect(this.tor_pool.next());
|
|
} else {
|
|
this.logger.debug(`[http-connect]: a connection has been attempted, but no tor instances are live... waiting for an instance to come online`);
|
|
this.tor_pool.once('instance_created', connect);
|
|
}
|
|
};
|
|
|
|
super(handle_http_connections);
|
|
this.on('connect', handle_connect_connections);
|
|
|
|
this.logger = logger || require('./winston-silent-logger');
|
|
this.tor_pool = tor_pool;
|
|
this.proxy_by_name = proxy_by_name;
|
|
}
|
|
};
|
|
|
|
module.exports = HTTPServer; |