309 lines
7.1 KiB
JavaScript
309 lines
7.1 KiB
JavaScript
const SocksAgent = require('socks5-http-client/lib/Agent');
|
|
const request = require('request');
|
|
const async = require('async');
|
|
const temp = require('temp');
|
|
temp.track();
|
|
const TorRouter = require('../');
|
|
const getPort = require('get-port');
|
|
const dns = require('native-dns');
|
|
const io = require('socket.io-client');
|
|
const _ = require('lodash');
|
|
|
|
const get_ip = function (callback) {
|
|
request({
|
|
url: 'http://monip.org',
|
|
agentClass: SocksAgent,
|
|
agentOptions: {
|
|
socksHost: '127.0.0.1',
|
|
socksPort: this.socks_port
|
|
}
|
|
}, (error, res, body) => {
|
|
var ip;
|
|
if (body)
|
|
ip = body.split('IP : ').pop().split('<').shift();
|
|
|
|
callback(error || (!body && new Error("Couldn't grab IP")), ip)
|
|
});
|
|
};
|
|
|
|
|
|
// describe('ControlServer', function () {
|
|
// let ports = {};
|
|
// var controlServer;
|
|
// var client;
|
|
|
|
// before((done) => {
|
|
// async.autoInject({
|
|
// dnsPort: (cb) => { getPort().then((port) => { cb(null, port); }) },
|
|
// socksPort: (cb) => { getPort().then((port) => { cb(null, port); }) },
|
|
// controlPort: (cb) => { getPort().then((port) => { cb(null, port); }) }
|
|
// }, (error, context) => {
|
|
// _.extend(ports, context);
|
|
|
|
// done(error);
|
|
// });
|
|
// });
|
|
|
|
// controlServer = new TorRouter.ControlServer();
|
|
|
|
// describe('#listen(port, callback)', () => {
|
|
// it('should listen on the control port', (done) => { controlServer.listen(ports.controlPort, done); })
|
|
// it('should connect to control server', (done) => {
|
|
// client = io.connect(`ws://127.0.0.1:${ports.controlPort}`);
|
|
|
|
// client.once('connect_error', (err) => {
|
|
// console.log(err)
|
|
// done(err);
|
|
// });
|
|
|
|
// client.once('connected', () => {
|
|
// done();
|
|
// })
|
|
// });
|
|
// });
|
|
|
|
// describe('#createTorPool(options)', function () {
|
|
// it('should create a tor pool', () => {
|
|
// client.emit('createTorPool', {});
|
|
// });
|
|
// });
|
|
|
|
// describe('#createSOCKSServer(port)', function () {
|
|
// it('should create a socks server', () => {
|
|
// client.emit('createSOCKSServer', ports.socksPort);
|
|
// });
|
|
// });
|
|
|
|
// describe('#createInstances(instances, callback)', function () {
|
|
// this.timeout(Infinity);
|
|
// it('should create 1 instance', function (done) {
|
|
// client.emit('createInstances', 1, (err) => {
|
|
// if (err) return done(error);
|
|
|
|
// done(((controlServer.torPool.instances.length !== 1) && new Error(`It doesn't have 1 instance`)));
|
|
// });
|
|
// })
|
|
// })
|
|
|
|
// describe('#newIps()', function (done) {
|
|
// var oldip;
|
|
// this.timeout(Infinity);
|
|
// it('should grab the current ip', (done) => {
|
|
// get_ip.call({ socks_port: ports.socksPort })((error, ip) => {
|
|
// oldip = ip;
|
|
// done(error);
|
|
// });
|
|
// });
|
|
|
|
// it('should change the ip', (done) => {
|
|
// client.emit('newIps');
|
|
// setTimeout(() => {
|
|
// done();
|
|
// }, 1000);
|
|
// });
|
|
|
|
// it('should have a diffrent ip', (done) => {
|
|
// get_ip.call({ socks_port: ports.socksPort })((error, ip) => {
|
|
// done(((oldip === ip) && new Error("ip hasn't changed")));
|
|
// });
|
|
// });
|
|
// });
|
|
|
|
// after(() => {
|
|
// controlServer.torPool.exit();
|
|
// client.close();
|
|
// controlServer.close();
|
|
// });
|
|
// });
|
|
|
|
|
|
describe('TorProcess', function () {
|
|
const TOR_DATA_DIR = temp.mkdirSync();
|
|
const TorProcess = TorRouter.TorProcess;
|
|
|
|
describe('#create()', function () {
|
|
var tor = new TorProcess('tor', { DataDirectory: TOR_DATA_DIR });
|
|
|
|
this.timeout(Infinity);
|
|
|
|
it('should create the process without an error', function (done) {
|
|
tor.create(done);
|
|
});
|
|
|
|
it('should signal ready when bootstrapped', function (done) {
|
|
tor.once('error', done);
|
|
tor.once('ready', done);
|
|
});
|
|
|
|
after('shutdown tor', function () {
|
|
tor.exit();
|
|
});
|
|
});
|
|
|
|
describe('#new_ip()', function () {
|
|
var tor = new TorProcess('tor', { DataDirectory: TOR_DATA_DIR });
|
|
var old_ip = null;
|
|
this.timeout(Infinity);
|
|
|
|
|
|
before('create a tor instance', function (done) {
|
|
tor.once('error', done);
|
|
tor.once('ready', done);
|
|
tor.create();
|
|
});
|
|
|
|
it('should have an ip address', function (done) {
|
|
get_ip.call({ socks_port: tor.socks_port }, (err, ip) => {
|
|
if (err) return done(err);
|
|
|
|
old_ip = ip;
|
|
done(err);
|
|
});
|
|
});
|
|
|
|
it('should have a new ip address after sending HUP', function (done) {
|
|
tor.new_ip();
|
|
setTimeout(() => {
|
|
get_ip.call({ socks_port: tor.socks_port }, (err, ip) => {
|
|
if (err) return done(err);
|
|
|
|
if (ip === old_ip)
|
|
done(new Error(`IP hasn't changed ${old_ip} === ${ip}`));
|
|
else
|
|
done();
|
|
});
|
|
}, (10*1000));
|
|
});
|
|
|
|
after('shutdown tor', function () {
|
|
tor.exit();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('TorPool', function () {
|
|
var TorPool = TorRouter.TorPool;
|
|
var pool = new TorPool('tor');
|
|
this.timeout(Infinity);
|
|
describe('#create', function () {
|
|
it('should create two instances without any problems', function (done) {
|
|
pool.create(2, function (error) {
|
|
if (error) return done(error);
|
|
done((pool.instances.length !== 2) && new Error('pool does not have two instances'));
|
|
});
|
|
});
|
|
|
|
});
|
|
|
|
describe('#remove', function () {
|
|
it('should remove 2 instances from the pool', function (done) {
|
|
pool.remove(2, function (error) {
|
|
if (error) return done(error);
|
|
done((pool.instances.length) && new Error('pool has two instances'));
|
|
})
|
|
});
|
|
})
|
|
|
|
after(function () {
|
|
pool.exit();
|
|
});
|
|
})
|
|
|
|
describe('DNSServer', function () {
|
|
var TorPool = TorRouter.TorPool;
|
|
var DNSServer = TorRouter.DNSServer;
|
|
var port;
|
|
var pool = new TorPool('tor');
|
|
var dns_server = new DNSServer(pool);
|
|
describe('#on("request")', function () {
|
|
this.timeout(Infinity);
|
|
|
|
|
|
before((done) => {
|
|
getPort().then(($port) => {
|
|
port = $port;
|
|
dns_server.serve(port);
|
|
done()
|
|
});
|
|
})
|
|
|
|
it('should startup tor', (done) => {
|
|
|
|
pool.create(2, done);
|
|
})
|
|
|
|
it('should be able to resolve "google.com" ', function (done) {
|
|
|
|
|
|
let req = dns.Request({
|
|
question: dns.Question({ name: 'google.com', type: 'A' }),
|
|
server: { address: '127.0.0.1', port: port, type: 'udp' },
|
|
timeout: 5000
|
|
});
|
|
|
|
req.on('timeout', () => {
|
|
done && done(new Error("Request timed out"));
|
|
done = null;
|
|
});
|
|
|
|
req.on('message', (e, m) => {
|
|
done && done(((!m) || (!m.answer.length)) && new Error('Unable to resolve host'));
|
|
done = null;
|
|
});
|
|
|
|
req.send();
|
|
});
|
|
|
|
after(function () {
|
|
pool.exit();
|
|
dns_server.close();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('SOCKSServer', function () {
|
|
var TorPool = TorRouter.TorPool;
|
|
var SOCKSServer = TorRouter.SOCKSServer;
|
|
|
|
var pool = new TorPool('tor');
|
|
var socks = new SOCKSServer(pool);
|
|
|
|
this.timeout(Infinity);
|
|
|
|
var port;
|
|
|
|
before((done) => {
|
|
getPort().then(($port) => {
|
|
port = $port;
|
|
socks.listen(port, (done));
|
|
});
|
|
})
|
|
|
|
describe('#on("connection")', function () {
|
|
var ip;
|
|
|
|
it('should startup tor ', (done) => {
|
|
pool.create(2, done);
|
|
})
|
|
|
|
it('should get an ip address', function (done) {
|
|
get_ip.call({ socks_port: port }, (err, _ip) => {
|
|
ip = _ip;
|
|
done(err || (!ip && new Error('could not get an ip')))
|
|
});
|
|
});
|
|
|
|
it('should have a different ip', function (done) {
|
|
get_ip.call({ socks_port: port }, (err, _ip) => {
|
|
|
|
done(err || (!ip && new Error('could not get an ip')) || ((_ip === ip) && new Error('IP has not changed')));
|
|
});
|
|
});
|
|
|
|
after(() => {
|
|
pool.exit();
|
|
socks.close();
|
|
});
|
|
});
|
|
});
|
|
|