node-mitmproxy-pro 1.0.0 → 1.1.0

package/lib/mitmproxy/createRequestHandler.js

@@ -0,0 +1,187 @@
+'use strict';
+
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
+var http = require('http');
+var https = require('https');
+var url = require('url');
+
+var _require = require('uuid'),
+    uuidv4 = _require.v4;
+
+var commonUtil = require('../common/util');
+var upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i;
+
+// create requestHandler function
+module.exports = function createRequestHandler(requestInterceptor, responseInterceptor, middlewares, externalProxy) {
+
+    var requestId = uuidv4();
+
+    // return
+    return function requestHandler(req, res, ssl) {
+        var _this = this;
+
+        var proxyReq;
+
+        var rOptions = commonUtil.getOptionsFormRequest(req, ssl, externalProxy);
+
+        if (rOptions.headers.connection === 'close') {
+            req.socket.setKeepAlive(false);
+        } else if (rOptions.customSocketId != null) {
+            // for NTLM
+            req.socket.setKeepAlive(true, 60 * 60 * 1000);
+        } else {
+            req.socket.setKeepAlive(true, 30000);
+        }
+
+        var requestInterceptorPromise = function requestInterceptorPromise() {
+            return new Promise(function (resolve, reject) {
+                var next = function next() {
+                    resolve();
+                };
+                try {
+                    if (typeof requestInterceptor === 'function') {
+                        requestInterceptor.call(null, requestId, rOptions, req, res, proxyReq, ssl, next);
+                    } else {
+                        resolve();
+                    }
+                } catch (e) {
+                    reject(e);
+                }
+            });
+        };
+
+        var proxyRequestPromise = function proxyRequestPromise() {
+            return new Promise(function (resolve, reject) {
+
+                rOptions.host = rOptions.hostname || rOptions.host || 'localhost';
+
+                // use the binded socket for NTLM
+                if (rOptions.agent && rOptions.customSocketId != null && rOptions.agent.getName) {
+                    var socketName = rOptions.agent.getName(rOptions);
+                    var bindingSocket = rOptions.agent.sockets[socketName];
+                    if (bindingSocket && bindingSocket.length > 0) {
+                        bindingSocket[0].once('free', onFree);
+                        return;
+                    }
+                }
+                onFree();
+                function onFree() {
+                    proxyReq = (rOptions.protocol == 'https:' ? https : http).request(rOptions, function (proxyRes) {
+                        resolve(proxyRes);
+                    });
+                    proxyReq.on('timeout', function () {
+                        reject(rOptions.host + ':' + rOptions.port + ', request timeout');
+                    });
+
+                    proxyReq.on('error', function (e) {
+                        reject(e);
+                    });
+
+                    proxyReq.on('aborted', function () {
+                        reject('server aborted reqest');
+                        req.abort();
+                    });
+
+                    req.on('aborted', function () {
+                        proxyReq.abort();
+                    });
+                    requestInterceptorPromise();
+                    // req.pipe(proxyReq);
+                }
+            });
+        };
+
+        // workflow control
+        _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+            var proxyRes, responseInterceptorPromise;
+            return regeneratorRuntime.wrap(function _callee$(_context) {
+                while (1) {
+                    switch (_context.prev = _context.next) {
+                        case 0:
+                            _context.next = 2;
+                            return proxyRequestPromise();
+
+                        case 2:
+                            proxyRes = _context.sent;
+
+                            if (!res.finished) {
+                                _context.next = 5;
+                                break;
+                            }
+
+                            return _context.abrupt('return', false);
+
+                        case 5:
+                            responseInterceptorPromise = new Promise(function (resolve, reject) {
+                                var next = function next() {
+                                    resolve();
+                                };
+                                try {
+                                    if (typeof responseInterceptor === 'function') {
+                                        responseInterceptor.call(null, requestId, res, proxyRes, ssl, next);
+                                    } else {
+                                        resolve();
+                                    }
+                                } catch (e) {
+                                    reject(e);
+                                }
+                            });
+                            _context.next = 8;
+                            return responseInterceptorPromise;
+
+                        case 8:
+                            if (!res.finished) {
+                                _context.next = 10;
+                                break;
+                            }
+
+                            return _context.abrupt('return', false);
+
+                        case 10:
+                            _context.prev = 10;
+
+                            if (!res.headersSent) {
+                                // prevent duplicate set headers
+                                Object.keys(proxyRes.headers).forEach(function (key) {
+                                    if (proxyRes.headers[key] != undefined) {
+                                        // https://github.com/nodejitsu/node-http-proxy/issues/362
+                                        if (/^www-authenticate$/i.test(key)) {
+                                            if (proxyRes.headers[key]) {
+                                                proxyRes.headers[key] = proxyRes.headers[key] && proxyRes.headers[key].split(',');
+                                            }
+                                            key = 'www-authenticate';
+                                        }
+                                        res.setHeader(key, proxyRes.headers[key]);
+                                    }
+                                });
+
+                                res.writeHead(proxyRes.statusCode);
+                                proxyRes.pipe(res);
+                            }
+                            _context.next = 17;
+                            break;
+
+                        case 14:
+                            _context.prev = 14;
+                            _context.t0 = _context['catch'](10);
+                            throw _context.t0;
+
+                        case 17:
+                        case 'end':
+                            return _context.stop();
+                    }
+                }
+            }, _callee, _this, [[10, 14]]);
+        }))().then(function (flag) {
+            // do nothing
+        }, function (e) {
+            if (!res.finished) {
+                res.writeHead(500);
+                res.write('Node-MitmProxy Warning:\n\n ' + e.toString());
+                res.end();
+            }
+            console.error(e);
+        });
+    };
+};

package/lib/mitmproxy/createUpgradeHandler.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var http = require('http');
+var https = require('https');
+var url = require('url');
+var util = require('../common/util');
+
+// copy from node-http-proxy.  ^_^
+
+// create connectHandler function
+module.exports = function createUpgradeHandler() {
+
+    // return
+    return function upgradeHandler(req, cltSocket, head, ssl) {
+        var clientOptions = util.getOptionsFormRequest(req, ssl);
+        var proxyReq = (ssl ? https : http).request(clientOptions);
+        proxyReq.on('error', function (e) {
+            console.error(e);
+        });
+        proxyReq.on('response', function (res) {
+            // if upgrade event isn't going to happen, close the socket
+            if (!res.upgrade) cltSocket.end();
+        });
+
+        proxyReq.on('upgrade', function (proxyRes, proxySocket, proxyHead) {
+            proxySocket.on('error', function (e) {
+                console.error(e);
+            });
+
+            cltSocket.on('error', function () {
+                proxySocket.end();
+            });
+
+            proxySocket.setTimeout(0);
+            proxySocket.setNoDelay(true);
+
+            proxySocket.setKeepAlive(true, 0);
+
+            if (proxyHead && proxyHead.length) proxySocket.unshift(proxyHead);
+
+            cltSocket.write(Object.keys(proxyRes.headers).reduce(function (head, key) {
+                var value = proxyRes.headers[key];
+
+                if (!Array.isArray(value)) {
+                    head.push(key + ': ' + value);
+                    return head;
+                }
+
+                for (var i = 0; i < value.length; i++) {
+                    head.push(key + ': ' + value[i]);
+                }
+                return head;
+            }, ['HTTP/1.1 101 Switching Protocols']).join('\r\n') + '\r\n\r\n');
+
+            proxySocket.pipe(cltSocket).pipe(proxySocket);
+        });
+        proxyReq.end();
+    };
+};

package/lib/mitmproxy/index.js

@@ -0,0 +1,100 @@
+'use strict';
+
+var tlsUtils = require('../tls/tlsUtils');
+var http = require('http');
+var config = require('../common/config');
+var colors = require('colors');
+var createRequestHandler = require('./createRequestHandler');
+var createConnectHandler = require('./createConnectHandler');
+var createFakeServerCenter = require('./createFakeServerCenter');
+var createUpgradeHandler = require('./createUpgradeHandler');
+
+module.exports = {
+    /**
+     * 启动中间人代理服务器
+     * @param {Object} options 配置
+     * @param {Number} options.port 代理端口
+     * @param {String} options.caCertPath CA证书路径
+     * @param {String} options.caKeyPath CA私钥路径
+     * @param {Function} options.sslConnectInterceptor SSL连接拦截器
+     * @param {Function} options.requestInterceptor 请求拦截器
+     * @param {Function} options.responseInterceptor 响应拦截器
+     * @param {Number} options.getCertSocketTimeout 获取证书超时时间
+     * @param {Array} options.middlewares 中间件
+     * @param {Object} options.externalProxy 外部代理
+     * @returns {http.Server} http代理服务器（关闭请使用.close()方法）
+     */
+    createProxy: function createProxy(_ref) {
+        var _ref$port = _ref.port,
+            port = _ref$port === undefined ? config.defaultPort : _ref$port,
+            caCertPath = _ref.caCertPath,
+            caKeyPath = _ref.caKeyPath,
+            sslConnectInterceptor = _ref.sslConnectInterceptor,
+            requestInterceptor = _ref.requestInterceptor,
+            responseInterceptor = _ref.responseInterceptor,
+            _ref$getCertSocketTim = _ref.getCertSocketTimeout,
+            getCertSocketTimeout = _ref$getCertSocketTim === undefined ? 1 * 1000 : _ref$getCertSocketTim,
+            _ref$middlewares = _ref.middlewares,
+            middlewares = _ref$middlewares === undefined ? [] : _ref$middlewares,
+            externalProxy = _ref.externalProxy;
+
+
+        // Don't reject unauthorized
+        process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = '0';
+
+        if (!caCertPath && !caKeyPath) {
+            var rs = this.createCA();
+            caCertPath = rs.caCertPath;
+            caKeyPath = rs.caKeyPath;
+            if (rs.create) {
+                console.log(colors.cyan('CA Cert saved in: ' + caCertPath));
+                console.log(colors.cyan('CA private key saved in: ' + caKeyPath));
+            }
+        }
+
+        port = ~~port;
+        var requestHandler = createRequestHandler(requestInterceptor, responseInterceptor, middlewares, externalProxy);
+
+        var upgradeHandler = createUpgradeHandler();
+
+        var fakeServersCenter = createFakeServerCenter({
+            caCertPath: caCertPath,
+            caKeyPath: caKeyPath,
+            requestHandler: requestHandler,
+            upgradeHandler: upgradeHandler,
+            getCertSocketTimeout: getCertSocketTimeout
+        });
+
+        var connectHandler = createConnectHandler(sslConnectInterceptor, fakeServersCenter);
+
+        var server = new http.Server();
+        server.listen(port, function () {
+            console.log(colors.green('node-mitmproxy\u542F\u52A8\u7AEF\u53E3: ' + port));
+            server.on('error', function (e) {
+                console.error(colors.red(e));
+            });
+            server.on('request', function (req, res) {
+                var ssl = false;
+                requestHandler(req, res, ssl);
+            });
+            // tunneling for https
+            server.on('connect', function (req, cltSocket, head) {
+                connectHandler(req, cltSocket, head);
+            });
+            // TODO: handler WebSocket
+            server.on('upgrade', function (req, socket, head) {
+                var ssl = false;
+                upgradeHandler(req, socket, head, ssl);
+            });
+        });
+
+        return server;
+    },
+
+    // 创建CA证书
+    createCA: function createCA() {
+        var caBasePath = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : config.getDefaultCABasePath();
+
+        return tlsUtils.initCA(caBasePath);
+    }
+};

package/lib/mitmproxy/middlewareHandler.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var _ = require('lodash');
+module.exports = function (middlewares) {
+    if (middlewares) {
+        if (Object.prototype.toString.call(middlewares) !== '[object Array]') {
+            throw new TypeError('middlewares must be a array');
+        }
+    }
+
+    var sslConnectInterceptors = [];
+    var requestInterceptors = [];
+    var responseInterceptors = [];
+
+    _.each(middlewares, function (m) {
+        if (m.buildIn === false || m.buildIn === 'false') {} else {
+            m.name;
+        }
+    });
+};

package/lib/tls/CertAndKeyContainer.js

@@ -0,0 +1,119 @@
+'use strict';
+
+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; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var tlsUtils = require('./tlsUtils');
+var https = require('https');
+
+module.exports = function () {
+    function CertAndKeyContainer(_ref) {
+        var _ref$maxLength = _ref.maxLength,
+            maxLength = _ref$maxLength === undefined ? 1000 : _ref$maxLength,
+            _ref$getCertSocketTim = _ref.getCertSocketTimeout,
+            getCertSocketTimeout = _ref$getCertSocketTim === undefined ? 2 * 1000 : _ref$getCertSocketTim,
+            caCert = _ref.caCert,
+            caKey = _ref.caKey;
+
+        _classCallCheck(this, CertAndKeyContainer);
+
+        this.queue = [];
+        this.maxLength = maxLength;
+        this.getCertSocketTimeout = getCertSocketTimeout;
+        this.caCert = caCert;
+        this.caKey = caKey;
+    }
+
+    _createClass(CertAndKeyContainer, [{
+        key: 'addCertPromise',
+        value: function addCertPromise(certPromiseObj) {
+            if (this.queue.length >= this.maxLength) {
+                this.queue.shift();
+            }
+            this.queue.push(certPromiseObj);
+            return certPromiseObj;
+        }
+    }, {
+        key: 'getCertPromise',
+        value: function getCertPromise(hostname, port) {
+            var _this = this;
+
+            for (var i = 0; i < this.queue.length; i++) {
+                var _certPromiseObj = this.queue[i];
+                var mappingHostNames = _certPromiseObj.mappingHostNames;
+                for (var j = 0; j < mappingHostNames.length; j++) {
+                    var DNSName = mappingHostNames[j];
+                    if (tlsUtils.isMappingHostName(DNSName, hostname)) {
+                        this.reRankCert(i);
+                        return _certPromiseObj.promise;
+                    }
+                }
+            }
+
+            var certPromiseObj = {
+                mappingHostNames: [hostname] // temporary hostname
+            };
+
+            var promise = new Promise(function (resolve, reject) {
+                var once = true;
+                var _resolve = function _resolve(_certObj) {
+                    if (once) {
+                        once = false;
+                        var mappingHostNames = tlsUtils.getMappingHostNamesFormCert(_certObj.cert);
+                        certPromiseObj.mappingHostNames = mappingHostNames; // change
+                        resolve(_certObj);
+                    }
+                };
+                var certObj = void 0;
+                var preReq = https.request({
+                    port: port,
+                    hostname: hostname,
+                    path: '/',
+                    method: 'HEAD'
+                }, function (preRes) {
+                    try {
+                        var realCert = preRes.socket.getPeerCertificate();
+                        if (realCert) {
+                            try {
+                                certObj = tlsUtils.createFakeCertificateByCA(_this.caKey, _this.caCert, realCert);
+                            } catch (error) {
+                                certObj = tlsUtils.createFakeCertificateByDomain(_this.caKey, _this.caCert, hostname);
+                            }
+                        } else {
+                            certObj = tlsUtils.createFakeCertificateByDomain(_this.caKey, _this.caCert, hostname);
+                        }
+                        _resolve(certObj);
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                preReq.setTimeout(~~_this.getCertSocketTimeout, function () {
+                    if (!certObj) {
+                        certObj = tlsUtils.createFakeCertificateByDomain(_this.caKey, _this.caCert, hostname);
+                        _resolve(certObj);
+                    }
+                });
+                preReq.on('error', function (e) {
+                    if (!certObj) {
+                        certObj = tlsUtils.createFakeCertificateByDomain(_this.caKey, _this.caCert, hostname);
+                        _resolve(certObj);
+                    }
+                });
+                preReq.end();
+            });
+
+            certPromiseObj.promise = promise;
+
+            return this.addCertPromise(certPromiseObj).promise;
+        }
+    }, {
+        key: 'reRankCert',
+        value: function reRankCert(index) {
+            // index ==> queue foot
+            this.queue.push(this.queue.splice(index, 1)[0]);
+        }
+    }]);
+
+    return CertAndKeyContainer;
+}();

package/lib/tls/FakeServersCenter.js

@@ -0,0 +1,173 @@
+'use strict';
+
+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; }; }();
+
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var https = require('https');
+var tlsUtils = require('./tlsUtils');
+var CertAndKeyContainer = require('./CertAndKeyContainer');
+var forge = require('node-forge');
+var pki = forge.pki;
+var colors = require('colors');
+var tls = require('tls');
+
+module.exports = function () {
+    function FakeServersCenter(_ref) {
+        var _ref$maxLength = _ref.maxLength,
+            maxLength = _ref$maxLength === undefined ? 100 : _ref$maxLength,
+            requestHandler = _ref.requestHandler,
+            upgradeHandler = _ref.upgradeHandler,
+            caCert = _ref.caCert,
+            caKey = _ref.caKey,
+            getCertSocketTimeout = _ref.getCertSocketTimeout;
+
+        _classCallCheck(this, FakeServersCenter);
+
+        this.queue = [];
+        this.maxLength = maxLength;
+        this.requestHandler = requestHandler;
+        this.upgradeHandler = upgradeHandler;
+        this.certAndKeyContainer = new CertAndKeyContainer({
+            getCertSocketTimeout: getCertSocketTimeout,
+            caCert: caCert,
+            caKey: caKey
+        });
+    }
+
+    _createClass(FakeServersCenter, [{
+        key: 'addServerPromise',
+        value: function addServerPromise(serverPromiseObj) {
+            if (this.queue.length >= this.maxLength) {
+                var delServerObj = this.queue.shift();
+                try {
+                    delServerObj.serverObj.server.close();
+                } catch (e) {
+                    console.log(e);
+                }
+            }
+            this.queue.push(serverPromiseObj);
+            return serverPromiseObj;
+        }
+    }, {
+        key: 'getServerPromise',
+        value: function getServerPromise(hostname, port) {
+            var _this = this;
+
+            for (var i = 0; i < this.queue.length; i++) {
+                var _serverPromiseObj = this.queue[i];
+                var mappingHostNames = _serverPromiseObj.mappingHostNames;
+                for (var j = 0; j < mappingHostNames.length; j++) {
+                    var DNSName = mappingHostNames[j];
+                    if (tlsUtils.isMappingHostName(DNSName, hostname)) {
+                        this.reRankServer(i);
+                        return _serverPromiseObj.promise;
+                    }
+                }
+            }
+
+            var serverPromiseObj = {
+                mappingHostNames: [hostname] // temporary hostname
+            };
+
+            var promise = new Promise(function (resolve, reject) {
+
+                _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
+                    var certObj, cert, key, certPem, keyPem, fakeServer, serverObj;
+                    return regeneratorRuntime.wrap(function _callee2$(_context2) {
+                        while (1) {
+                            switch (_context2.prev = _context2.next) {
+                                case 0:
+                                    _context2.next = 2;
+                                    return _this.certAndKeyContainer.getCertPromise(hostname, port);
+
+                                case 2:
+                                    certObj = _context2.sent;
+                                    cert = certObj.cert;
+                                    key = certObj.key;
+                                    certPem = pki.certificateToPem(cert);
+                                    keyPem = pki.privateKeyToPem(key);
+                                    fakeServer = new https.Server({
+                                        key: keyPem,
+                                        cert: certPem,
+                                        SNICallback: function SNICallback(hostname, done) {
+                                            _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+                                                var certObj;
+                                                return regeneratorRuntime.wrap(function _callee$(_context) {
+                                                    while (1) {
+                                                        switch (_context.prev = _context.next) {
+                                                            case 0:
+                                                                _context.next = 2;
+                                                                return _this.certAndKeyContainer.getCertPromise(hostname, port);
+
+                                                            case 2:
+                                                                certObj = _context.sent;
+
+                                                                done(null, tls.createSecureContext({
+                                                                    key: pki.privateKeyToPem(certObj.key),
+                                                                    cert: pki.certificateToPem(certObj.cert)
+                                                                }));
+
+                                                            case 4:
+                                                            case 'end':
+                                                                return _context.stop();
+                                                        }
+                                                    }
+                                                }, _callee, _this);
+                                            }))();
+                                        }
+                                    });
+                                    serverObj = {
+                                        cert: cert,
+                                        key: key,
+                                        server: fakeServer,
+                                        port: 0 // if prot === 0 ,should listen server's `listening` event.
+                                    };
+
+                                    serverPromiseObj.serverObj = serverObj;
+                                    fakeServer.listen(0, function () {
+                                        var address = fakeServer.address();
+                                        serverObj.port = address.port;
+                                    });
+                                    fakeServer.on('request', function (req, res) {
+                                        var ssl = true;
+                                        _this.requestHandler(req, res, ssl);
+                                    });
+                                    fakeServer.on('error', function (e) {
+                                        console.error(e);
+                                    });
+                                    fakeServer.on('listening', function () {
+                                        var mappingHostNames = tlsUtils.getMappingHostNamesFormCert(certObj.cert);
+                                        serverPromiseObj.mappingHostNames = mappingHostNames;
+                                        resolve(serverObj);
+                                    });
+                                    fakeServer.on('upgrade', function (req, socket, head) {
+                                        var ssl = true;
+                                        _this.upgradeHandler(req, socket, head, ssl);
+                                    });
+
+                                case 15:
+                                case 'end':
+                                    return _context2.stop();
+                            }
+                        }
+                    }, _callee2, _this);
+                }))();
+            });
+
+            serverPromiseObj.promise = promise;
+
+            return this.addServerPromise(serverPromiseObj).promise;
+        }
+    }, {
+        key: 'reRankServer',
+        value: function reRankServer(index) {
+            // index ==> queue foot
+            this.queue.push(this.queue.splice(index, 1)[0]);
+        }
+    }]);
+
+    return FakeServersCenter;
+}();