node-mitmproxy-pro 1.0.0 → 1.1.0

package/README.md

@@ -44,7 +44,6 @@ module.exports = {
 效果图：  
 <img width=500 src="./doc/img/hello_node-mitmproxy.jpg" />
 
-[详细配置说明](https://github.com/CyrilGuoCODE/node-mitmproxy-pro#4配置详细说明)  
 [更多例子](./example/config/)
 #### 启动方式
 ```
@@ -61,7 +60,6 @@ sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keyc
 ```
 ###### windows
 注: 证书需要安装到  ** 受信任的根证书目录 ** 下  
-参考 [issues#3](https://github.com/CyrilGuoCODE/node-mitmproxy-pro/issues/3)
 ```
 start %HOMEPATH%/node-mitmproxy-pro/node-mitmproxy-pro.ca.crt
 ```

package/lib/bin/index.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+'use strict';
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+require('babel-polyfill');
+var mitmproxy = require('../mitmproxy/index');
+var program = require('commander');
+var packageJson = require('../../package.json');
+var tlsUtils = require('../tls/tlsUtils');
+var fs = require('fs');
+var path = require('path');
+var colors = require('colors');
+
+fs.existsSync = fs.existsSync || path.existsSync;
+
+program.version(packageJson.version).option('-c, --config [value]', 'config file path').parse(process.argv);
+
+console.log(program.config);
+
+var configPath = path.resolve(program.config);
+
+if (fs.existsSync(configPath)) {
+
+    var configObject = require(configPath);
+
+    if ((typeof configObject === 'undefined' ? 'undefined' : _typeof(configObject)) !== 'object') {
+        console.error(colors.red('Config Error in ' + configPath));
+    } else {
+        mitmproxy.createProxy(configObject);
+    }
+} else {
+    console.error(colors.red('Can not find `config file` file: ' + configPath));
+}

package/lib/common/ProxyHttpAgent.js

@@ -0,0 +1,37 @@
+'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"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+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; }
+
+var AgentOrigin = require('agentkeepalive');
+
+module.exports = function (_AgentOrigin) {
+    _inherits(Agent, _AgentOrigin);
+
+    function Agent() {
+        _classCallCheck(this, Agent);
+
+        return _possibleConstructorReturn(this, (Agent.__proto__ || Object.getPrototypeOf(Agent)).apply(this, arguments));
+    }
+
+    _createClass(Agent, [{
+        key: 'getName',
+
+        // Hacky
+        value: function getName(option) {
+            var name = AgentOrigin.prototype.getName.call(this, option);
+            name += ':';
+            if (option.customSocketId) {
+                name += option.customSocketId;
+            }
+            return name;
+        }
+    }]);
+
+    return Agent;
+}(AgentOrigin);

package/lib/common/ProxyHttpsAgent.js

@@ -0,0 +1,37 @@
+'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"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+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; }
+
+var HttpsAgentOrigin = require('agentkeepalive').HttpsAgent;
+
+module.exports = function (_HttpsAgentOrigin) {
+    _inherits(HttpsAgent, _HttpsAgentOrigin);
+
+    function HttpsAgent() {
+        _classCallCheck(this, HttpsAgent);
+
+        return _possibleConstructorReturn(this, (HttpsAgent.__proto__ || Object.getPrototypeOf(HttpsAgent)).apply(this, arguments));
+    }
+
+    _createClass(HttpsAgent, [{
+        key: 'getName',
+
+        // Hacky
+        value: function getName(option) {
+            var name = HttpsAgentOrigin.prototype.getName.call(this, option);
+            name += ':';
+            if (option.customSocketId) {
+                name += option.customSocketId;
+            }
+            return name;
+        }
+    }]);
+
+    return HttpsAgent;
+}(HttpsAgentOrigin);

package/lib/common/config.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var path = require('path');
+
+var config = exports;
+
+config.caCertFileName = 'node-mitmproxy.ca.crt';
+
+config.caKeyFileName = 'node-mitmproxy.ca.key.pem';
+
+config.defaultPort = 6789;
+
+config.caName = 'node-mitmproxy CA';
+
+config.getDefaultCABasePath = function () {
+    var userHome = process.env.HOME || process.env.USERPROFILE;
+    return path.resolve(userHome, './node-mitmproxy');
+};
+
+config.getDefaultCACertPath = function () {
+    return path.resolve(config.getDefaultCABasePath(), config.caCertFileName);
+};
+
+config.getDefaultCACertPath = function () {
+    return path.resolve(config.getDefaultCABasePath(), config.caKeyFileName);
+};

package/lib/common/util.js

@@ -0,0 +1,143 @@
+'use strict';
+
+var url = require('url');
+var Agent = require('./ProxyHttpAgent');
+var HttpsAgent = require('./ProxyHttpsAgent');
+var tunnelAgent = require('tunnel-agent');
+
+var util = exports;
+var httpsAgent = new HttpsAgent({
+    keepAlive: true,
+    timeout: 60000,
+    keepAliveTimeout: 30000, // free socket keepalive for 30 seconds
+    rejectUnauthorized: false
+});
+var httpAgent = new Agent({
+    keepAlive: true,
+    timeout: 60000,
+    keepAliveTimeout: 30000 // free socket keepalive for 30 seconds
+});
+var socketId = 0;
+
+var httpOverHttpAgent, httpsOverHttpAgent, httpOverHttpsAgent, httpsOverHttpsAgent;
+
+util.getOptionsFormRequest = function (req, ssl) {
+    var externalProxy = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+    var urlObject = url.parse(req.url);
+    var defaultPort = ssl ? 443 : 80;
+    var protocol = ssl ? 'https:' : 'http:';
+    var headers = Object.assign({}, req.headers);
+    var externalProxyUrl = null;
+
+    if (externalProxy) {
+        if (typeof externalProxy === 'string') {
+            externalProxyUrl = externalProxy;
+        } else if (typeof externalProxy === 'function') {
+            try {
+                externalProxyUrl = externalProxy(req, ssl);
+            } catch (e) {
+                console.error(e);
+            }
+        }
+    }
+
+    delete headers['proxy-connection'];
+    var agent = false;
+    if (!externalProxyUrl) {
+        // keepAlive
+        if (headers.connection !== 'close') {
+            if (protocol == 'https:') {
+                agent = httpsAgent;
+            } else {
+                agent = httpAgent;
+            }
+            headers.connection = 'keep-alive';
+        }
+    } else {
+        agent = util.getTunnelAgent(protocol === 'https:', externalProxyUrl);
+    }
+
+    var options = {
+        protocol: protocol,
+        hostname: req.headers.host.split(':')[0],
+        method: req.method,
+        port: req.headers.host.split(':')[1] || defaultPort,
+        path: urlObject.path,
+        headers: req.headers,
+        agent: agent
+    };
+
+    if (protocol === 'http:' && externalProxyUrl && url.parse(externalProxyUrl).protocol === 'http:') {
+        var externalURL = url.parse(externalProxyUrl);
+        options.hostname = externalURL.hostname;
+        options.port = externalURL.port;
+        // support non-transparent proxy
+        options.path = 'http://' + urlObject.host + urlObject.path;
+    }
+
+    // mark a socketId for Agent to bind socket for NTLM
+    if (req.socket.customSocketId) {
+        options.customSocketId = req.socket.customSocketId;
+    } else if (headers['authorization']) {
+        options.customSocketId = req.socket.customSocketId = socketId++;
+    }
+
+    return options;
+};
+
+util.getTunnelAgent = function (requestIsSSL, externalProxyUrl) {
+    var urlObject = url.parse(externalProxyUrl);
+    var protocol = urlObject.protocol || 'http:';
+    var port = urlObject.port;
+    if (!port) {
+        port = protocol === 'http:' ? 80 : 443;
+    }
+    var hostname = urlObject.hostname || 'localhost';
+
+    if (requestIsSSL) {
+        if (protocol === 'http:') {
+            if (!httpsOverHttpAgent) {
+                httpsOverHttpAgent = tunnelAgent.httpsOverHttp({
+                    proxy: {
+                        host: hostname,
+                        port: port
+                    }
+                });
+            }
+            return httpsOverHttpAgent;
+        } else {
+            if (!httpsOverHttpsAgent) {
+                httpsOverHttpsAgent = tunnelAgent.httpsOverHttps({
+                    proxy: {
+                        host: hostname,
+                        port: port
+                    }
+                });
+            }
+            return httpsOverHttpsAgent;
+        }
+    } else {
+        if (protocol === 'http:') {
+            // if (!httpOverHttpAgent) {
+            //     httpOverHttpAgent = tunnelAgent.httpOverHttp({
+            //         proxy: {
+            //             host: hostname,
+            //             port: port
+            //         }
+            //     });
+            // }
+            return false;
+        } else {
+            if (!httpOverHttpsAgent) {
+                httpOverHttpsAgent = tunnelAgent.httpOverHttps({
+                    proxy: {
+                        host: hostname,
+                        port: port
+                    }
+                });
+            }
+            return httpOverHttpsAgent;
+        }
+    }
+};

package/lib/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+require('babel-polyfill');
+module.exports = require('./mitmproxy');

package/lib/middleware/FilterMiddleware.js

@@ -0,0 +1 @@
+"use strict";

package/lib/middleware/HtmlMiddleware.js

@@ -0,0 +1,107 @@
+'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 through = require('through2');
+var zlib = require('zlib');
+var url = require('url');
+
+var httpUtil = {};
+httpUtil.isGzip = function (res) {
+    var contentEncoding = res.headers['content-encoding'];
+    return !!(contentEncoding && contentEncoding.toLowerCase() == 'gzip');
+};
+httpUtil.isHtml = function (res) {
+    var contentType = res.headers['content-type'];
+    return typeof contentType != 'undefined' && /text\/html|application\/xhtml\+xml/.test(contentType);
+};
+
+function injectContentIntoHtmlHead(html, content) {
+    html = html.replace(/(<\/head>)/i, function (match) {
+        return content + match;
+    });
+    return html;
+}
+
+function injectContentIntoHtmlBody(html, content) {
+    html = html.replace(/(<\/body>)/i, function (match) {
+        return content + match;
+    });
+    return html;
+}
+
+function chunkReplace(_this, chunk, enc, callback, headContent, bodyContent) {
+    var chunkString = chunk.toString();
+    if (headContent) {
+        chunkString = injectScriptIntoHtmlHead(chunkString, headContent);
+    }
+    if (bodyContent) {
+        chunkString = injectContentIntoHtmlBody(chunkString, bodyContent);
+    }
+    _this.push(new Buffer(chunkString));
+    callback();
+}
+
+module.exports = function () {
+    function InjectHtmlPlugin(_ref) {
+        var head = _ref.head,
+            body = _ref.body;
+
+        _classCallCheck(this, InjectHtmlPlugin);
+
+        this.head = head;
+        this.body = body;
+    }
+
+    _createClass(InjectHtmlPlugin, [{
+        key: 'responseInterceptor',
+        value: function responseInterceptor(req, res, proxyReq, proxyRes, ssl, next) {
+
+            if (!this.head && !this.body) {
+                next();
+                return;
+            }
+
+            var isHtml = httpUtil.isHtml(proxyRes);
+            var contentLengthIsZero = function () {
+                return proxyRes.headers['content-length'] == 0;
+            }();
+            if (!isHtml || contentLengthIsZero) {
+                next();
+            } else {
+                Object.keys(proxyRes.headers).forEach(function (key) {
+                    if (proxyRes.headers[key] != undefined) {
+                        var newkey = key.replace(/^[a-z]|-[a-z]/g, function (match) {
+                            return match.toUpperCase();
+                        });
+                        var newkey = key;
+                        if (isHtml && key === 'content-length') {
+                            // do nothing
+                        } else {
+                            res.setHeader(newkey, proxyRes.headers[key]);
+                        }
+                    }
+                });
+
+                res.writeHead(proxyRes.statusCode);
+
+                var isGzip = httpUtil.isGzip(proxyRes);
+
+                if (isGzip) {
+                    proxyRes.pipe(new zlib.Gunzip()).pipe(through(function (chunk, enc, callback) {
+                        chunkReplace(this, chunk, enc, callback, this.head, this.body);
+                    })).pipe(new zlib.Gzip()).pipe(res);
+                } else {
+                    proxyRes.pipe(through(function (chunk, enc, callback) {
+                        chunkReplace(this, chunk, enc, callback, this.head, this.body);
+                    })).pipe(res);
+                }
+            }
+            next();
+        }
+    }]);
+
+    return InjectHtmlPlugin;
+}();

package/lib/middleware/MapLocalMiddleware.js

@@ -0,0 +1 @@
+"use strict";

package/lib/middleware/MapRemoteMiddleware.js

@@ -0,0 +1 @@
+"use strict";

package/lib/mitmproxy/createConnectHandler.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var net = require('net');
+var url = require('url');
+var colors = require('colors');
+
+var localIP = '127.0.0.1';
+// create connectHandler function
+module.exports = function createConnectHandler(sslConnectInterceptor, fakeServerCenter) {
+
+    // return
+    return function connectHandler(req, cltSocket, head) {
+
+        var srvUrl = url.parse('https://' + req.url);
+
+        if (typeof sslConnectInterceptor === 'function' && sslConnectInterceptor.call(null, req, cltSocket, head)) {
+            fakeServerCenter.getServerPromise(srvUrl.hostname, srvUrl.port).then(function (serverObj) {
+                connect(req, cltSocket, head, localIP, serverObj.port);
+            }, function (e) {
+                console.error(e);
+            });
+        } else {
+            connect(req, cltSocket, head, srvUrl.hostname, srvUrl.port);
+        }
+    };
+};
+
+function connect(req, cltSocket, head, hostname, port) {
+    // tunneling https
+    var proxySocket = net.connect(port, hostname, function () {
+        cltSocket.write('HTTP/1.1 200 Connection Established\r\n' + 'Proxy-agent: node-mitmproxy\r\n' + '\r\n');
+        proxySocket.write(head);
+        proxySocket.pipe(cltSocket);
+        cltSocket.pipe(proxySocket);
+    });
+    proxySocket.on('error', function (e) {
+        console.log(colors.red(e));
+    });
+    return proxySocket;
+}

package/lib/mitmproxy/createFakeServerCenter.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var config = require('../common/config');
+var fs = require('fs');
+var path = require('path');
+var forge = require('node-forge');
+var FakeServersCenter = require('../tls/FakeServersCenter');
+var colors = require('colors');
+
+module.exports = function createFakeServerCenter(_ref) {
+    var caCertPath = _ref.caCertPath,
+        caKeyPath = _ref.caKeyPath,
+        requestHandler = _ref.requestHandler,
+        upgradeHandler = _ref.upgradeHandler,
+        getCertSocketTimeout = _ref.getCertSocketTimeout;
+
+    var caCert;
+    var caKey;
+    try {
+        fs.accessSync(caCertPath, fs.F_OK);
+        fs.accessSync(caKeyPath, fs.F_OK);
+        var caCertPem = fs.readFileSync(caCertPath);
+        var caKeyPem = fs.readFileSync(caKeyPath);
+        caCert = forge.pki.certificateFromPem(caCertPem);
+        caKey = forge.pki.privateKeyFromPem(caKeyPem);
+    } catch (e) {
+        console.log(colors.red('Can not find `CA certificate` or `CA key`.'), e);
+        process.exit(1);
+    }
+
+    return new FakeServersCenter({
+        caCert: caCert,
+        caKey: caKey,
+        maxLength: 100,
+        requestHandler: requestHandler,
+        upgradeHandler: upgradeHandler,
+        getCertSocketTimeout: getCertSocketTimeout
+    });
+};