proxy_chain_rb 0.1.0 → 0.1.2

data/lib/proxy_chain_rb/node_js/proxy-chain-server/node_modules/proxy-chain/build/handler_forward.js

@@ -16,6 +16,8 @@ var _handler_base = require('./handler_base');
 
 var _handler_base2 = _interopRequireDefault(_handler_base);
 
+var _server = require('./server');
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
@@ -51,21 +53,30 @@ var HandlerForward = function (_HandlerBase) {
             // var hasVia = false;
             // var via = '1.1 ' + hostname + ' (proxy/' + version + ')';
 
+            var hostHeaderFound = false;
+
+            // TODO: We should probably use a raw HTTP message via socket instead of http.request(),
+            // since Node transforms the headers to lower case and thus makes it easy to detect the proxy
             for (var i = 0; i < this.srcRequest.rawHeaders.length; i += 2) {
                 var headerName = this.srcRequest.rawHeaders[i];
                 var headerValue = this.srcRequest.rawHeaders[i + 1];
 
-                if (headerName === 'Connection' && headerValue === 'keep-alive') {
+                if (/^connection$/i.test(headerName) && /^keep-alive$/i.test(headerValue)) {
                     // Keep the "Connection: keep-alive" header, to reduce the chance that the server
                     // will detect we're not a browser and also to improve performance
                 } else if ((0, _tools.isHopByHopHeader)(headerName)) {
                     continue;
                 } else if ((0, _tools.isInvalidHeader)(headerName, headerValue)) {
                     continue;
+                } else if (/^host$/i.test(headerName)) {
+                    // If Host header was used multiple times, only consider the first one.
+                    // This is to prevent "TypeError: hostHeader.startsWith is not a function at calculateServerName (_http_agent.js:240:20)"
+                    if (hostHeaderFound) continue;
+                    hostHeaderFound = true;
                 }
 
                 /*
-                 if (!hasXForwardedFor && 'x-forwarded-for' === keyLower) {
+                if (!hasXForwardedFor && 'x-forwarded-for' === keyLower) {
                     // append to existing "X-Forwarded-For" header
                     // http://en.wikipedia.org/wiki/X-Forwarded-For
                     hasXForwardedFor = true;
@@ -137,12 +148,9 @@ var HandlerForward = function (_HandlerBase) {
         value: function onTrgResponse(response) {
             if (this.isClosed) return;
             this.log('Received response from target (' + response.statusCode + ')');
-            // console.dir(response);
 
             if (this.checkUpstreamProxy407(response)) return;
 
-            this.srcGotResponse = true;
-
             // Prepare response headers
             var headers = {};
             for (var i = 0; i < response.rawHeaders.length; i += 2) {
@@ -155,6 +163,16 @@ var HandlerForward = function (_HandlerBase) {
                 (0, _tools.addHeader)(headers, name, value);
             }
 
+            // Ensure status code is in the range accepted by Node, otherwise proxy will crash with
+            // "RangeError: Invalid status code: 0" (see writeHead in Node's _http_server.js)
+            // Fixes https://github.com/apifytech/proxy-chain/issues/35
+            if (response.statusCode < 100 || response.statusCode > 999) {
+                this.fail(new _server.RequestError('Target server responded with an invalid HTTP status code (' + response.statusCode + ')', 500));
+                return;
+            }
+
+            this.srcGotResponse = true;
+
             this.srcResponse.writeHead(response.statusCode, headers);
             response.pipe(this.srcResponse);
         }

data/lib/proxy_chain_rb/node_js/proxy-chain-server/node_modules/proxy-chain/build/handler_tunnel_chain.js

@@ -24,10 +24,6 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen
 
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-// import { tee } from './tools';
-
-/* globals Buffer */
-
 /**
  * Represents a connection from source client to an external proxy using HTTP CONNECT tunnel.
  */
@@ -68,8 +64,8 @@ var HandlerTunnelChain = function (_HandlerBase) {
 
             this.trgRequest.once('connect', this.onTrgRequestConnect);
             this.trgRequest.once('abort', this.onTrgRequestAbort);
-            this.trgRequest.once('error', this.onTrgRequestError);
-            this.trgRequest.on('socket', this.onTrgSocket);
+            this.trgRequest.once('socket', this.onTrgSocket);
+            this.trgRequest.on('error', this.onTrgRequestError);
 
             // Send the data
             this.trgRequest.end();
@@ -84,7 +80,7 @@ var HandlerTunnelChain = function (_HandlerBase) {
 
             this.srcGotResponse = true;
             this.srcResponse.removeListener('finish', this.onSrcResponseFinish);
-            this.srcResponse.writeHead(200, 'Connection established');
+            this.srcResponse.writeHead(200, 'Connection Established');
 
             // HACK: force a flush of the HTTP header. This is to ensure 'head' is empty to avoid
             // assert at https://github.com/request/tunnel-agent/blob/master/index.js#L160

data/lib/proxy_chain_rb/node_js/proxy-chain-server/node_modules/proxy-chain/build/handler_tunnel_direct.js

@@ -56,7 +56,7 @@ var HandlerTunnelDirect = function (_HandlerBase) {
             this.srcGotResponse = true;
 
             this.srcResponse.removeListener('finish', this.onSrcResponseFinish);
-            this.srcResponse.writeHead(200, 'Connection established');
+            this.srcResponse.writeHead(200, 'Connection Established');
 
             // HACK: force a flush of the HTTP header. This is to ensure 'head' is empty to avoid
             // assert at https://github.com/request/tunnel-agent/blob/master/index.js#L160

data/lib/proxy_chain_rb/node_js/proxy-chain-server/node_modules/proxy-chain/build/index.js

@@ -6,9 +6,7 @@ var _tools = require('./tools');
 
 var _anonymize_proxy = require('./anonymize_proxy');
 
-var _tcp_tunnel = require('./tcp_tunnel');
-
-/* globals module */
+var _tcp_tunnel_tools = require('./tcp_tunnel_tools');
 
 // Publicly exported functions and classes
 var ProxyChain = {
@@ -19,8 +17,8 @@ var ProxyChain = {
     redactParsedUrl: _tools.redactParsedUrl,
     anonymizeProxy: _anonymize_proxy.anonymizeProxy,
     closeAnonymizedProxy: _anonymize_proxy.closeAnonymizedProxy,
-    createTunnel: _tcp_tunnel.createTunnel,
-    closeTunnel: _tcp_tunnel.closeTunnel
+    createTunnel: _tcp_tunnel_tools.createTunnel,
+    closeTunnel: _tcp_tunnel_tools.closeTunnel
 };
 
 module.exports = ProxyChain;

data/lib/proxy_chain_rb/node_js/proxy-chain-server/node_modules/proxy-chain/build/server.js

@@ -172,7 +172,7 @@ var Server = exports.Server = function (_EventEmitter) {
         value: function log(handlerId, str) {
             if (this.verbose) {
                 var logPrefix = handlerId ? handlerId + ' | ' : '';
-                console.log('Server[' + this.port + ']: ' + logPrefix + str);
+                console.log('ProxyServer[' + this.port + ']: ' + logPrefix + str);
             }
         }
     }, {
@@ -270,6 +270,7 @@ var Server = exports.Server = function (_EventEmitter) {
             this.log(handlerOpts.id, '!!! Handling ' + request.method + ' ' + request.url + ' HTTP/' + request.httpVersion);
 
             var socket = request.socket;
+
             var isHttp = false;
 
             return _bluebird2.default.resolve().then(function () {
@@ -585,6 +586,7 @@ var Server = exports.Server = function (_EventEmitter) {
             // TODO: keep track of all handlers and close them if closeConnections=true
             if (this.server) {
                 var server = this.server;
+
                 this.server = null;
                 return _bluebird2.default.promisify(server.close).bind(server)().nodeify(callback);
             }

data/lib/proxy_chain_rb/node_js/proxy-chain-server/node_modules/proxy-chain/build/tcp_tunnel.js

@@ -4,135 +4,265 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 
-var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+var _http = require('http');
 
-exports.createTunnel = createTunnel;
-exports.closeTunnel = closeTunnel;
+var _http2 = _interopRequireDefault(_http);
 
-var _bluebird = require('bluebird');
+var _tools = require('./tools');
 
-var _bluebird2 = _interopRequireDefault(_bluebird);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _net = require('net');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var _net2 = _interopRequireDefault(_net);
+/**
+ * Represents a connection from source client to an external proxy using HTTP CONNECT tunnel, allows TCP connection.
+ */
+var TcpTunnel = function () {
+    function TcpTunnel(_ref) {
+        var srcSocket = _ref.srcSocket,
+            trgParsed = _ref.trgParsed,
+            upstreamProxyUrlParsed = _ref.upstreamProxyUrlParsed,
+            log = _ref.log;
 
-var _handler_tunnel_tcp_chain = require('./handler_tunnel_tcp_chain');
+        _classCallCheck(this, TcpTunnel);
 
-var _handler_tunnel_tcp_chain2 = _interopRequireDefault(_handler_tunnel_tcp_chain);
+        this.log = log;
 
-var _tools = require('./tools');
+        // Bind all event handlers to this instance
+        this.bindHandlersToThis(['onSrcSocketClose', 'onSrcSocketEnd', 'onSrcSocketError', 'onTrgSocket', 'onTrgSocketClose', 'onTrgSocketEnd', 'onTrgSocketError', 'onTrgRequestConnect', 'onTrgRequestAbort', 'onTrgRequestError']);
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+        if (!trgParsed.hostname) throw new Error('The "trgParsed.hostname" option is required');
+        if (!trgParsed.port) throw new Error('The "trgParsed.port" option is required');
 
-var runningServers = {};
-
-function createTunnel(proxyUrl, targetHost) {
-    var providedOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    var callback = arguments[3];
-
-    // TODO: More and better validations - yeah, make sure targetHost is really a hostname
-    var _targetHost$split = targetHost.split(':'),
-        _targetHost$split2 = _slicedToArray(_targetHost$split, 2),
-        trgHostname = _targetHost$split2[0],
-        trgPort = _targetHost$split2[1];
-
-    if (!trgHostname || !trgPort) throw new Error('target needs to include both hostname and port.');
-
-    var parsedProxyUrl = (0, _tools.parseUrl)(proxyUrl);
-    if (!parsedProxyUrl.hostname) throw new Error('proxyUrl needs to include atleast hostname');
-    if (parsedProxyUrl.scheme !== 'http') throw new Error('Currently only "http" scheme is supported');
-
-    var options = _extends({
-        verbose: false,
-        hostname: 'localhost',
-        port: null
-    }, providedOptions);
-
-    return new _bluebird2.default(function (resolve, reject) {
-        if (options.port) return resolve(options.port);
-        (0, _tools.findFreePort)().then(resolve).catch(reject);
-    }).then(function (port) {
-        var server = _net2.default.createServer();
-
-        var log = function log() {
-            var _console;
-
-            if (options.verbose) (_console = console).log.apply(_console, arguments);
-        };
-
-        server.on('connection', function (srcSocket) {
-            runningServers[port].connections = srcSocket;
-            var remoteAddress = srcSocket.remoteAddress + ':' + srcSocket.remotePort;
-            log('new client connection from %s', remoteAddress);
-
-            srcSocket.pause();
-
-            var tunnel = new _handler_tunnel_tcp_chain2.default({
-                srcSocket: srcSocket,
-                upstreamProxyUrlParsed: parsedProxyUrl,
-                trgParsed: {
-                    hostname: trgHostname,
-                    port: trgPort
-                },
-                log: log
-            });
+        this.trgRequest = null;
+        this.trgSocket = null;
+        this.trgParsed = trgParsed;
+        this.trgParsed.port = this.trgParsed.port || DEFAULT_TARGET_PORT;
 
-            tunnel.run();
+        this.srcSocket = srcSocket;
+        this.srcSocket.once('close', this.onSrcSocketClose);
+        this.srcSocket.once('end', this.onSrcSocketEnd);
+        this.srcSocket.on('error', this.onSrcSocketError);
 
-            srcSocket.on('data', onConnData);
-            srcSocket.once('close', onConnClose);
-            srcSocket.on('error', onConnError);
+        this.upstreamProxyUrlParsed = upstreamProxyUrlParsed;
 
-            function onConnData(d) {
-                log('connection data from %s: %j', remoteAddress, d);
-            }
+        this.isClosed = false;
+    }
 
-            function onConnClose() {
-                log('connection from %s closed', remoteAddress);
-            }
+    _createClass(TcpTunnel, [{
+        key: 'bindHandlersToThis',
+        value: function bindHandlersToThis(handlerNames) {
+            var _this = this;
 
-            function onConnError(err) {
-                log('Connection %s error: %s', remoteAddress, err.message);
-            }
-        });
-
-        return new _bluebird2.default(function (resolve) {
-            server.listen(port, function (err) {
-                if (err) return reject(err);
-                log('server listening to ', server.address());
-                runningServers[port] = { server: server, connections: [] };
-                resolve(options.hostname + ':' + port);
-            });
-        });
-    }).nodeify(callback);
-}
-
-function closeTunnel(serverPath, closeConnections, callback) {
-    var _serverPath$split = serverPath.split(':'),
-        _serverPath$split2 = _slicedToArray(_serverPath$split, 2),
-        hostname = _serverPath$split2[0],
-        port = _serverPath$split2[1];
-
-    if (!hostname) throw new Error('serverPath must contain hostname');
-    if (!port) throw new Error('serverPath must contain port');
-
-    return new _bluebird2.default(function (resolve) {
-        if (!runningServers[port]) return resolve(false);
-        if (!closeConnections) return resolve();
-        runningServers[port].connections.forEach(function (connection) {
-            return connection.destroy();
-        });
-        resolve();
-    }).then(function (serverExists) {
-        return new _bluebird2.default(function (resolve) {
-            if (!serverExists) return resolve(false);
-            runningServers[port].close(function () {
-                delete runningServers[port];
-                resolve(true);
+            handlerNames.forEach(function (evt) {
+                _this[evt] = _this[evt].bind(_this);
             });
-        });
-    }).nodeify(callback);
-}
+        }
+    }, {
+        key: 'run',
+        value: function run() {
+            this.log('Connecting to upstream proxy...');
+
+            var options = {
+                method: 'CONNECT',
+                hostname: this.upstreamProxyUrlParsed.hostname,
+                port: this.upstreamProxyUrlParsed.port,
+                path: this.trgParsed.hostname + ':' + this.trgParsed.port,
+                headers: {}
+            };
+
+            (0, _tools.maybeAddProxyAuthorizationHeader)(this.upstreamProxyUrlParsed, options.headers);
+
+            this.trgRequest = _http2.default.request(options);
+
+            this.trgRequest.once('connect', this.onTrgRequestConnect);
+            this.trgRequest.once('abort', this.onTrgRequestAbort);
+            this.trgRequest.once('socket', this.onTrgSocket);
+            this.trgRequest.on('error', this.onTrgRequestError);
+
+            // Send the data
+            this.trgRequest.end();
+        }
+
+        // If the client closes the connection prematurely,
+        // then immediately destroy the upstream socket, there's nothing we can do with it
+
+    }, {
+        key: 'onSrcSocketClose',
+        value: function onSrcSocketClose() {
+            if (this.isClosed) return;
+            this.log('Source socket closed');
+            this.close();
+        }
+    }, {
+        key: 'onSrcSocketEnd',
+        value: function onSrcSocketEnd() {
+            if (this.isClosed) return;
+            this.log('Source socket ended');
+            this.close();
+        }
+    }, {
+        key: 'onSrcSocketError',
+        value: function onSrcSocketError(err) {
+            if (this.isClosed) return;
+            this.log('Source socket failed: ' + (err.stack || err));
+            this.close();
+        }
+    }, {
+        key: 'onTrgSocket',
+        value: function onTrgSocket(socket) {
+            if (this.isClosed) return;
+
+            this.log('Target socket assigned');
+
+            this.trgSocket = socket;
+
+            socket.once('close', this.onTrgSocketClose);
+            socket.once('end', this.onTrgSocketEnd);
+            socket.on('error', this.onTrgSocketError);
+        }
+
+        // Once target socket closes, we need to give time
+        // to source socket to receive pending data, so we only call end()
+
+    }, {
+        key: 'onTrgSocketClose',
+        value: function onTrgSocketClose() {
+            var _this2 = this;
+
+            if (this.isClosed) return;
+            this.log('Target socket closed');
+            setTimeout(function () {
+                if (_this2.srcSocket) _this2.srcSocket.end();
+            }, 100);
+        }
+    }, {
+        key: 'onTrgSocketEnd',
+        value: function onTrgSocketEnd() {
+            var _this3 = this;
+
+            if (this.isClosed) return;
+            this.log('Target socket ended');
+            setTimeout(function () {
+                if (_this3.srcSocket) _this3.srcSocket.end();
+            }, 100);
+        }
+    }, {
+        key: 'onTrgSocketError',
+        value: function onTrgSocketError(err) {
+            if (this.isClosed) return;
+            this.log('Target socket failed: ' + (err.stack || err));
+            this.fail(err);
+        }
+    }, {
+        key: 'onTrgRequestConnect',
+        value: function onTrgRequestConnect(response) {
+            if (this.isClosed) return;
+            this.log('Connected to upstream proxy');
+
+            if (this.checkUpstreamProxy407(response)) return;
+
+            // Setup bi-directional tunnel
+            this.trgSocket.pipe(this.srcSocket);
+            this.srcSocket.pipe(this.trgSocket);
+
+            this.srcSocket.resume();
+        }
+    }, {
+        key: 'onTrgRequestAbort',
+        value: function onTrgRequestAbort() {
+            if (this.isClosed) return;
+            this.log('Target aborted');
+            this.close();
+        }
+    }, {
+        key: 'onTrgRequestError',
+        value: function onTrgRequestError(err) {
+            if (this.isClosed) return;
+            this.log('Target request failed: ' + (err.stack || err));
+            this.fail(err);
+        }
+
+        /**
+         * Checks whether response from upstream proxy is 407 Proxy Authentication Required
+         * and if so, responds 502 Bad Gateway to client.
+         * @param response
+         * @return {boolean}
+         */
+
+    }, {
+        key: 'checkUpstreamProxy407',
+        value: function checkUpstreamProxy407(response) {
+            if (this.upstreamProxyUrlParsed && response.statusCode === 407) {
+                this.fail('Invalid credentials provided for the upstream proxy.', 502);
+                return true;
+            }
+            return false;
+        }
+    }, {
+        key: 'fail',
+        value: function fail(err, statusCode) {
+            if (this.srcGotResponse) {
+                this.log('Source already received a response, just destroying the socket...');
+                this.close();
+            } else if (statusCode) {
+                // Manual error
+                this.log(err + ', responding with custom status code ' + statusCode + ' to client');
+            } else if (err.code === 'ENOTFOUND' && !this.upstreamProxyUrlParsed) {
+                this.log('Target server not found, sending 404 to client');
+            } else if (err.code === 'ENOTFOUND' && this.upstreamProxyUrlParsed) {
+                this.log('Upstream proxy not found, sending 502 to client');
+            } else if (err.code === 'ECONNREFUSED') {
+                this.log('Upstream proxy refused connection, sending 502 to client');
+            } else if (err.code === 'ETIMEDOUT') {
+                this.log('Connection timed out, sending 502 to client');
+            } else if (err.code === 'ECONNRESET') {
+                this.log('Connection lost, sending 502 to client');
+            } else if (err.code === 'EPIPE') {
+                this.log('Socket closed before write, sending 502 to client');
+            } else {
+                this.log('Unknown error, sending 500 to client');
+            }
+        }
+
+        /**
+         * Detaches all listeners and destroys all sockets.
+         */
+
+    }, {
+        key: 'close',
+        value: function close() {
+            if (!this.isClosed) {
+                this.log('Closing handler');
+
+                if (this.srcRequest) {
+                    this.srcRequest.destroy();
+                    this.srcRequest = null;
+                }
+
+                if (this.srcSocket) {
+                    this.srcSocket.destroy();
+                    this.srcSocket = null;
+                }
+
+                if (this.trgRequest) {
+                    this.trgRequest.abort();
+                    this.trgRequest = null;
+                }
+
+                if (this.trgSocket) {
+                    this.trgSocket.destroy();
+                    this.trgSocket = null;
+                }
+
+                this.isClosed = true;
+            }
+        }
+    }]);
+
+    return TcpTunnel;
+}();
+
+exports.default = TcpTunnel;