├── .gitignore
├── README.md
├── dist
    ├── index.d.ts
    └── index.js
├── package-lock.json
├── package.json
├── requirements.txt
├── scripts
    ├── install_python_deps.js
    ├── install_python_deps.py
    └── proxy.py
├── src
    └── index.ts
└── tsconfig.json


/.gitignore:
--------------------------------------------------------------------------------
1 | *.egg-info
2 | node_modules
3 | .vscode
4 | __pycache__
5 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # mitmproxy-node 2.1.1
 2 | 
 3 | A bridge between Python's [`mitmproxy`](https://mitmproxy.org/) and Node.JS programs. Rewrite network requests using Node.JS!
 4 | 
 5 | ## Why?
 6 | 
 7 | It is far easier to rewrite JavaScript/HTML/etc using JavaScript than Python, but mitmproxy only accepts Python plugins.
 8 | There are no decent alternatives to mitmproxy, so this package lets me use mitmproxy with Node.js-based rewriting code.
 9 | 
10 | ## What can I use this for?
11 | 
12 | For transparently rewriting HTTP/HTTPS responses. The mitmproxy plugin lets every HTTP request go through to the server uninhibited, and then passes it to Node.js via a WebSocket for rewriting. You can optionally specify a list of paths that should be directly intercepted without being passed to the server.
13 | 
14 | If you want to add additional functionality, such as filtering or whatnot, I'll accept pull requests so long as they do not noticeably hinder performance.
15 | 
16 | ## How does it work?
17 | 
18 | A Python plugin for `mitmproxy` starts a WebSocket server, and `mitmproxy-node` talks with it over WebSocket messages. The two communicate via binary messages to reduce marshaling-related overhead.
19 | 
20 | ## Your Python plugin is bad and you should feel bad
21 | 
22 | I have no idea what I am doing. PRs to improve my Python code are appreciated!
23 | 
24 | ## Pre-requisites
25 | 
26 | * [`mitmproxy` V4](https://mitmproxy.org/) must be installed and runnable from the terminal. The install method cannot be a prebuilt binary or homebrew, since those packages are missing the Python websockets module. Install via `pip` or from source.
27 | * Python 3.6, since I use the new async/await syntax in the mitmproxy plugin
28 | * `npm install` to pull in Node and PIP dependencies.
29 | 
30 | ## Using
31 | 
32 | You can either start `mitmproxy` manually with `mitmdump --anticache -s scripts/proxy.py`, or `mitmproxy-node` will do so automatically for you.
33 | `mitmproxy-node` auto-detects if `mitmproxy` is already running.
34 | If you frequently start/stop the proxy, it may be best to start it manually.
35 | 
36 | ```javascript
37 | import MITMProxy from 'mitmproxy-node';
38 | 
39 | // Returns Promise<MITMProxy>
40 | async function makeProxy() {
41 |   // Note: Your interceptor can also be asynchronous and return a Promise!
42 |   return MITMProxy.Create(function(interceptedMsg) {
43 |     const req = interceptedMsg.request;
44 |     const res = interceptedMsg.response;
45 |     if (req.rawUrl.contains("target.js") && res.getHeader('content-type').indexOf("javascript") !== -1) {
46 |       interceptedMsg.setResponseBody(Buffer.from(`Hacked!`, 'utf8'));
47 |     }
48 |   }, ['/eval'] /* list of paths to directly intercept -- don't send to server */,
49 |   true /* Be quiet; turn off for debug messages */,
50 |   true /* Only intercept text or potentially-text requests (all mime types with *application* and *text* in them, plus responses with no mime type) */
51 |   );
52 | }
53 | 
54 | async function main() {
55 |   const proxy = await makeProxy();
56 |   // when done:
57 |   await proxy.shutdown();
58 | }
59 | ```
60 | 
61 | Without fancy async/await:
62 | 
63 | ```javascript
64 | import MITMProxy from 'mitmproxy-node';
65 | 
66 | // Returns Promise<MITMProxy>
67 | function makeProxy() {
68 |   return MITMProxy.Create(function(interceptedMsg) {
69 |     const req = interceptedMsg.request;
70 |     const res = interceptedMsg.response;
71 |     if (req.rawUrl.contains("target.js") && res.getHeader('content-type').indexOf("javascript") !== -1) {
72 |       interceptedMsg.setResponseBody(Buffer.from(`Hacked!`, 'utf8'));
73 |     }
74 |   }, ['/eval'], true, true);
75 | }
76 | 
77 | function main() {
78 |   makeProxy().then((proxy) => {
79 |     // when done
80 |     proxy.shutdown.then(() => {
81 |       // Proxy is closed!
82 |     });
83 |   });
84 | }
85 | ```
86 | 
87 | ## Building
88 | 
89 | `npm run build`
90 | 


--------------------------------------------------------------------------------
/dist/index.d.ts:
--------------------------------------------------------------------------------
  1 | /// <reference types="node" />
  2 | import { Url } from 'url';
  3 | /**
  4 |  * Function that intercepts and rewrites HTTP responses.
  5 |  */
  6 | export declare type Interceptor = (m: InterceptedHTTPMessage) => void | Promise<void>;
  7 | /**
  8 |  * An interceptor that does nothing.
  9 |  */
 10 | export declare function nopInterceptor(m: InterceptedHTTPMessage): void;
 11 | /**
 12 |  * The core HTTP response.
 13 |  */
 14 | export interface HTTPResponse {
 15 |     statusCode: number;
 16 |     headers: {
 17 |         [name: string]: string;
 18 |     };
 19 |     body: Buffer;
 20 | }
 21 | /**
 22 |  * Metadata associated with an HTTP request.
 23 |  */
 24 | export interface HTTPRequestMetadata {
 25 |     method: string;
 26 |     url: string;
 27 |     headers: [string, string][];
 28 | }
 29 | /**
 30 |  * Metadata associated with an HTTP response.
 31 |  */
 32 | export interface HTTPResponseMetadata {
 33 |     status_code: number;
 34 |     headers: [string, string][];
 35 | }
 36 | /**
 37 |  * Abstract class that represents HTTP headers.
 38 |  */
 39 | export declare abstract class AbstractHTTPHeaders {
 40 |     private _headers;
 41 |     readonly headers: [string, string][];
 42 |     constructor(headers: [string, string][]);
 43 |     private _indexOfHeader(name);
 44 |     /**
 45 |      * Get the value of the given header field.
 46 |      * If there are multiple fields with that name, this only returns the first field's value!
 47 |      * @param name Name of the header field
 48 |      */
 49 |     getHeader(name: string): string;
 50 |     /**
 51 |      * Set the value of the given header field. Assumes that there is only one field with the given name.
 52 |      * If the field does not exist, it adds a new field with the name and value.
 53 |      * @param name Name of the field.
 54 |      * @param value New value.
 55 |      */
 56 |     setHeader(name: string, value: string): void;
 57 |     /**
 58 |      * Removes the header field with the given name. Assumes that there is only one field with the given name.
 59 |      * Does nothing if field does not exist.
 60 |      * @param name Name of the field.
 61 |      */
 62 |     removeHeader(name: string): void;
 63 |     /**
 64 |      * Removes all header fields.
 65 |      */
 66 |     clearHeaders(): void;
 67 | }
 68 | /**
 69 |  * Represents a MITM-ed HTTP response from a server.
 70 |  */
 71 | export declare class InterceptedHTTPResponse extends AbstractHTTPHeaders {
 72 |     statusCode: number;
 73 |     constructor(metadata: HTTPResponseMetadata);
 74 |     toJSON(): HTTPResponseMetadata;
 75 | }
 76 | /**
 77 |  * Represents an intercepted HTTP request from a client.
 78 |  */
 79 | export declare class InterceptedHTTPRequest extends AbstractHTTPHeaders {
 80 |     method: string;
 81 |     rawUrl: string;
 82 |     url: Url;
 83 |     constructor(metadata: HTTPRequestMetadata);
 84 | }
 85 | /**
 86 |  * Represents an intercepted HTTP request/response pair.
 87 |  */
 88 | export declare class InterceptedHTTPMessage {
 89 |     /**
 90 |      * Unpack from a Buffer received from MITMProxy.
 91 |      * @param b
 92 |      */
 93 |     static FromBuffer(b: Buffer): InterceptedHTTPMessage;
 94 |     readonly request: InterceptedHTTPRequest;
 95 |     readonly response: InterceptedHTTPResponse;
 96 |     readonly requestBody: Buffer;
 97 |     readonly responseBody: Buffer;
 98 |     private _responseBody;
 99 |     private constructor();
100 |     /**
101 |      * Changes the body of the HTTP response. Appropriately updates content-length.
102 |      * @param b The new body contents.
103 |      */
104 |     setResponseBody(b: Buffer): void;
105 |     /**
106 |      * Changes the status code of the HTTP response.
107 |      * @param code The new status code.
108 |      */
109 |     setStatusCode(code: number): void;
110 |     /**
111 |      * Pack into a buffer for transmission to MITMProxy.
112 |      */
113 |     toBuffer(): Buffer;
114 | }
115 | export declare class StashedItem {
116 |     readonly rawUrl: string;
117 |     readonly mimeType: string;
118 |     readonly data: Buffer;
119 |     constructor(rawUrl: string, mimeType: string, data: Buffer);
120 |     readonly shortMimeType: string;
121 |     readonly isHtml: boolean;
122 |     readonly isJavaScript: boolean;
123 | }
124 | /**
125 |  * Class that launches MITM proxy and talks to it via WebSockets.
126 |  */
127 | export default class MITMProxy {
128 |     private static _activeProcesses;
129 |     /**
130 |      * Creates a new MITMProxy instance.
131 |      * @param cb Called with intercepted HTTP requests / responses.
132 |      * @param interceptPaths List of paths to completely intercept without sending to the server (e.g. ['/eval'])
133 |      * @param quiet If true, do not print debugging messages (defaults to 'true').
134 |      * @param onlyInterceptTextFiles If true, only intercept text files (JavaScript/HTML/CSS/etc, and ignore media files).
135 |      */
136 |     static Create(cb?: Interceptor, interceptPaths?: string[], quiet?: boolean, onlyInterceptTextFiles?: boolean, ignoreHosts?: string | null): Promise<MITMProxy>;
137 |     private static _cleanupCalled;
138 |     private static _cleanup();
139 |     private _stashEnabled;
140 |     stashEnabled: boolean;
141 |     private _mitmProcess;
142 |     private _mitmError;
143 |     private _wss;
144 |     cb: Interceptor;
145 |     readonly onlyInterceptTextFiles: boolean;
146 |     private _stash;
147 |     private _stashFilter;
148 |     stashFilter: (url: string, item: StashedItem) => boolean;
149 |     private constructor();
150 |     private _initializeWSS(wss);
151 |     private _initializeMITMProxy(mitmProxy);
152 |     /**
153 |      * Retrieves the given URL from the stash.
154 |      * @param url
155 |      */
156 |     getFromStash(url: string): StashedItem;
157 |     forEachStashItem(cb: (value: StashedItem, url: string) => void): void;
158 |     /**
159 |      * Requests the given URL from the proxy.
160 |      */
161 |     proxyGet(urlString: string): Promise<HTTPResponse>;
162 |     shutdown(): Promise<void>;
163 | }
164 | 


--------------------------------------------------------------------------------
/dist/index.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
  3 |     return new (P || (P = Promise))(function (resolve, reject) {
  4 |         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  5 |         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  6 |         function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
  7 |         step((generator = generator.apply(thisArg, _arguments || [])).next());
  8 |     });
  9 | };
 10 | Object.defineProperty(exports, "__esModule", { value: true });
 11 | const ws_1 = require("ws");
 12 | const child_process_1 = require("child_process");
 13 | const path_1 = require("path");
 14 | const url_1 = require("url");
 15 | const http_1 = require("http");
 16 | const https_1 = require("https");
 17 | const net_1 = require("net");
 18 | /**
 19 |  * Wait for the specified port to open.
 20 |  * @param port The port to watch for.
 21 |  * @param retries The number of times to retry before giving up. Defaults to 10.
 22 |  * @param interval The interval between retries, in milliseconds. Defaults to 500.
 23 |  */
 24 | function waitForPort(port, retries = 10, interval = 500) {
 25 |     return new Promise((resolve, reject) => {
 26 |         let retriesRemaining = retries;
 27 |         let retryInterval = interval;
 28 |         let timer = null;
 29 |         let socket = null;
 30 |         function clearTimerAndDestroySocket() {
 31 |             clearTimeout(timer);
 32 |             timer = null;
 33 |             if (socket)
 34 |                 socket.destroy();
 35 |             socket = null;
 36 |         }
 37 |         function retry() {
 38 |             tryToConnect();
 39 |         }
 40 |         function tryToConnect() {
 41 |             clearTimerAndDestroySocket();
 42 |             if (--retriesRemaining < 0) {
 43 |                 reject(new Error('out of retries'));
 44 |             }
 45 |             socket = net_1.createConnection(port, "localhost", function () {
 46 |                 clearTimerAndDestroySocket();
 47 |                 if (retriesRemaining >= 0)
 48 |                     resolve();
 49 |             });
 50 |             timer = setTimeout(function () { retry(); }, retryInterval);
 51 |             socket.on('error', function (err) {
 52 |                 clearTimerAndDestroySocket();
 53 |                 setTimeout(retry, retryInterval);
 54 |             });
 55 |         }
 56 |         tryToConnect();
 57 |     });
 58 | }
 59 | /**
 60 |  * An interceptor that does nothing.
 61 |  */
 62 | function nopInterceptor(m) { }
 63 | exports.nopInterceptor = nopInterceptor;
 64 | /**
 65 |  * Abstract class that represents HTTP headers.
 66 |  */
 67 | class AbstractHTTPHeaders {
 68 |     // The raw headers, as a sequence of key/value pairs.
 69 |     // Since header fields may be repeated, this array may contain multiple entries for the same key.
 70 |     get headers() {
 71 |         return this._headers;
 72 |     }
 73 |     constructor(headers) {
 74 |         this._headers = headers;
 75 |     }
 76 |     _indexOfHeader(name) {
 77 |         const headers = this.headers;
 78 |         const len = headers.length;
 79 |         for (let i = 0; i < len; i++) {
 80 |             if (headers[i][0].toLowerCase() === name) {
 81 |                 return i;
 82 |             }
 83 |         }
 84 |         return -1;
 85 |     }
 86 |     /**
 87 |      * Get the value of the given header field.
 88 |      * If there are multiple fields with that name, this only returns the first field's value!
 89 |      * @param name Name of the header field
 90 |      */
 91 |     getHeader(name) {
 92 |         const index = this._indexOfHeader(name.toLowerCase());
 93 |         if (index !== -1) {
 94 |             return this.headers[index][1];
 95 |         }
 96 |         return '';
 97 |     }
 98 |     /**
 99 |      * Set the value of the given header field. Assumes that there is only one field with the given name.
100 |      * If the field does not exist, it adds a new field with the name and value.
101 |      * @param name Name of the field.
102 |      * @param value New value.
103 |      */
104 |     setHeader(name, value) {
105 |         const index = this._indexOfHeader(name.toLowerCase());
106 |         if (index !== -1) {
107 |             this.headers[index][1] = value;
108 |         }
109 |         else {
110 |             this.headers.push([name, value]);
111 |         }
112 |     }
113 |     /**
114 |      * Removes the header field with the given name. Assumes that there is only one field with the given name.
115 |      * Does nothing if field does not exist.
116 |      * @param name Name of the field.
117 |      */
118 |     removeHeader(name) {
119 |         const index = this._indexOfHeader(name.toLowerCase());
120 |         if (index !== -1) {
121 |             this.headers.splice(index, 1);
122 |         }
123 |     }
124 |     /**
125 |      * Removes all header fields.
126 |      */
127 |     clearHeaders() {
128 |         this._headers = [];
129 |     }
130 | }
131 | exports.AbstractHTTPHeaders = AbstractHTTPHeaders;
132 | /**
133 |  * Represents a MITM-ed HTTP response from a server.
134 |  */
135 | class InterceptedHTTPResponse extends AbstractHTTPHeaders {
136 |     constructor(metadata) {
137 |         super(metadata.headers);
138 |         this.statusCode = metadata.status_code;
139 |         // We don't support chunked transfers. The proxy already de-chunks it for us.
140 |         this.removeHeader('transfer-encoding');
141 |         // MITMProxy decodes the data for us.
142 |         this.removeHeader('content-encoding');
143 |         // CSP is bad!
144 |         this.removeHeader('content-security-policy');
145 |         this.removeHeader('x-webkit-csp');
146 |         this.removeHeader('x-content-security-policy');
147 |     }
148 |     toJSON() {
149 |         return {
150 |             status_code: this.statusCode,
151 |             headers: this.headers
152 |         };
153 |     }
154 | }
155 | exports.InterceptedHTTPResponse = InterceptedHTTPResponse;
156 | /**
157 |  * Represents an intercepted HTTP request from a client.
158 |  */
159 | class InterceptedHTTPRequest extends AbstractHTTPHeaders {
160 |     constructor(metadata) {
161 |         super(metadata.headers);
162 |         this.method = metadata.method.toLowerCase();
163 |         this.rawUrl = metadata.url;
164 |         this.url = url_1.parse(this.rawUrl);
165 |     }
166 | }
167 | exports.InterceptedHTTPRequest = InterceptedHTTPRequest;
168 | /**
169 |  * Represents an intercepted HTTP request/response pair.
170 |  */
171 | class InterceptedHTTPMessage {
172 |     /**
173 |      * Unpack from a Buffer received from MITMProxy.
174 |      * @param b
175 |      */
176 |     static FromBuffer(b) {
177 |         const metadataSize = b.readInt32LE(0);
178 |         const requestSize = b.readInt32LE(4);
179 |         const responseSize = b.readInt32LE(8);
180 |         const metadata = JSON.parse(b.toString("utf8", 12, 12 + metadataSize));
181 |         return new InterceptedHTTPMessage(new InterceptedHTTPRequest(metadata.request), new InterceptedHTTPResponse(metadata.response), b.slice(12 + metadataSize, 12 + metadataSize + requestSize), b.slice(12 + metadataSize + requestSize, 12 + metadataSize + requestSize + responseSize));
182 |     }
183 |     // The body of the HTTP response. Read-only; change the response body via setResponseBody.
184 |     get responseBody() {
185 |         return this._responseBody;
186 |     }
187 |     constructor(request, response, requestBody, responseBody) {
188 |         this.request = request;
189 |         this.response = response;
190 |         this.requestBody = requestBody;
191 |         this._responseBody = responseBody;
192 |     }
193 |     /**
194 |      * Changes the body of the HTTP response. Appropriately updates content-length.
195 |      * @param b The new body contents.
196 |      */
197 |     setResponseBody(b) {
198 |         this._responseBody = b;
199 |         // Update content-length.
200 |         this.response.setHeader('content-length', `${b.length}`);
201 |         // TODO: Content-encoding?
202 |     }
203 |     /**
204 |      * Changes the status code of the HTTP response.
205 |      * @param code The new status code.
206 |      */
207 |     setStatusCode(code) {
208 |         this.response.statusCode = code;
209 |     }
210 |     /**
211 |      * Pack into a buffer for transmission to MITMProxy.
212 |      */
213 |     toBuffer() {
214 |         const metadata = Buffer.from(JSON.stringify(this.response), 'utf8');
215 |         const metadataLength = metadata.length;
216 |         const responseLength = this._responseBody.length;
217 |         const rv = Buffer.alloc(8 + metadataLength + responseLength);
218 |         rv.writeInt32LE(metadataLength, 0);
219 |         rv.writeInt32LE(responseLength, 4);
220 |         metadata.copy(rv, 8);
221 |         this._responseBody.copy(rv, 8 + metadataLength);
222 |         return rv;
223 |     }
224 | }
225 | exports.InterceptedHTTPMessage = InterceptedHTTPMessage;
226 | class StashedItem {
227 |     constructor(rawUrl, mimeType, data) {
228 |         this.rawUrl = rawUrl;
229 |         this.mimeType = mimeType;
230 |         this.data = data;
231 |     }
232 |     get shortMimeType() {
233 |         let mime = this.mimeType.toLowerCase();
234 |         if (mime.indexOf(";") !== -1) {
235 |             mime = mime.slice(0, mime.indexOf(";"));
236 |         }
237 |         return mime;
238 |     }
239 |     get isHtml() {
240 |         return this.shortMimeType === "text/html";
241 |     }
242 |     get isJavaScript() {
243 |         switch (this.shortMimeType) {
244 |             case 'text/javascript':
245 |             case 'application/javascript':
246 |             case 'text/x-javascript':
247 |             case 'application/x-javascript':
248 |                 return true;
249 |             default:
250 |                 return false;
251 |         }
252 |     }
253 | }
254 | exports.StashedItem = StashedItem;
255 | function defaultStashFilter(url, item) {
256 |     return item.isJavaScript || item.isHtml;
257 | }
258 | /**
259 |  * Class that launches MITM proxy and talks to it via WebSockets.
260 |  */
261 | class MITMProxy {
262 |     constructor(cb, onlyInterceptTextFiles) {
263 |         this._stashEnabled = false;
264 |         this._mitmProcess = null;
265 |         this._mitmError = null;
266 |         this._wss = null;
267 |         this._stash = new Map();
268 |         this._stashFilter = defaultStashFilter;
269 |         this.cb = cb;
270 |         this.onlyInterceptTextFiles = onlyInterceptTextFiles;
271 |     }
272 |     /**
273 |      * Creates a new MITMProxy instance.
274 |      * @param cb Called with intercepted HTTP requests / responses.
275 |      * @param interceptPaths List of paths to completely intercept without sending to the server (e.g. ['/eval'])
276 |      * @param quiet If true, do not print debugging messages (defaults to 'true').
277 |      * @param onlyInterceptTextFiles If true, only intercept text files (JavaScript/HTML/CSS/etc, and ignore media files).
278 |      */
279 |     static Create(cb = nopInterceptor, interceptPaths = [], quiet = true, onlyInterceptTextFiles = false, ignoreHosts = null) {
280 |         return __awaiter(this, void 0, void 0, function* () {
281 |             // Construct WebSocket server, and wait for it to begin listening.
282 |             const wss = new ws_1.Server({ port: 8765 });
283 |             const proxyConnected = new Promise((resolve, reject) => {
284 |                 wss.once('connection', () => {
285 |                     resolve();
286 |                 });
287 |             });
288 |             const mp = new MITMProxy(cb, onlyInterceptTextFiles);
289 |             // Set up WSS callbacks before MITMProxy connects.
290 |             mp._initializeWSS(wss);
291 |             yield new Promise((resolve, reject) => {
292 |                 wss.once('listening', () => {
293 |                     wss.removeListener('error', reject);
294 |                     resolve();
295 |                 });
296 |                 wss.once('error', reject);
297 |             });
298 |             try {
299 |                 try {
300 |                     yield waitForPort(8080, 1);
301 |                     if (!quiet) {
302 |                         console.log(`MITMProxy already running.`);
303 |                     }
304 |                 }
305 |                 catch (e) {
306 |                     if (!quiet) {
307 |                         console.log(`MITMProxy not running; starting up mitmproxy.`);
308 |                     }
309 |                     // Start up MITM process.
310 |                     // --anticache means to disable caching, which gets in the way of transparently rewriting content.
311 |                     const scriptArgs = interceptPaths.length > 0 ? ["--set", `intercept=${interceptPaths.join(",")}`] : [];
312 |                     scriptArgs.push("--set", `onlyInterceptTextFiles=${onlyInterceptTextFiles}`);
313 |                     if (ignoreHosts) {
314 |                         scriptArgs.push(`--ignore-hosts`, ignoreHosts);
315 |                     }
316 |                     const options = ["--anticache", "-s", path_1.resolve(__dirname, `../scripts/proxy.py`)].concat(scriptArgs);
317 |                     if (quiet) {
318 |                         options.push('-q');
319 |                     }
320 |                     // allow self-signed SSL certificates
321 |                     options.push("--ssl-insecure");
322 |                     const mitmProcess = child_process_1.spawn("mitmdump", options, {
323 |                         stdio: 'inherit'
324 |                     });
325 |                     const mitmProxyExited = new Promise((_, reject) => {
326 |                         mitmProcess.once('error', reject);
327 |                         mitmProcess.once('exit', reject);
328 |                     });
329 |                     if (MITMProxy._activeProcesses.push(mitmProcess) === 1) {
330 |                         process.on('SIGINT', MITMProxy._cleanup);
331 |                         process.on('exit', MITMProxy._cleanup);
332 |                     }
333 |                     mp._initializeMITMProxy(mitmProcess);
334 |                     // Wait for port 8080 to come online.
335 |                     const waitingForPort = waitForPort(8080);
336 |                     try {
337 |                         // Fails if mitmproxy exits before port becomes available.
338 |                         yield Promise.race([mitmProxyExited, waitingForPort]);
339 |                     }
340 |                     catch (e) {
341 |                         if (e && typeof (e) === 'object' && e.code === "ENOENT") {
342 |                             throw new Error(`mitmdump, which is an executable that ships with mitmproxy, is not on your PATH. Please ensure that you can run mitmdump --version successfully from your command line.`);
343 |                         }
344 |                         else {
345 |                             throw new Error(`Unable to start mitmproxy: ${e}`);
346 |                         }
347 |                     }
348 |                 }
349 |                 yield proxyConnected;
350 |             }
351 |             catch (e) {
352 |                 yield new Promise((resolve) => wss.close(resolve));
353 |                 throw e;
354 |             }
355 |             return mp;
356 |         });
357 |     }
358 |     static _cleanup() {
359 |         if (MITMProxy._cleanupCalled) {
360 |             return;
361 |         }
362 |         MITMProxy._cleanupCalled = true;
363 |         MITMProxy._activeProcesses.forEach((p) => {
364 |             p.kill('SIGKILL');
365 |         });
366 |     }
367 |     // Toggle whether or not mitmproxy-node stashes modified server responses.
368 |     // **Not used for performance**, but enables Node.js code to fetch previous server responses from the proxy.
369 |     get stashEnabled() {
370 |         return this._stashEnabled;
371 |     }
372 |     set stashEnabled(v) {
373 |         if (!v) {
374 |             this._stash.clear();
375 |         }
376 |         this._stashEnabled = v;
377 |     }
378 |     get stashFilter() {
379 |         return this._stashFilter;
380 |     }
381 |     set stashFilter(value) {
382 |         if (typeof (value) === 'function') {
383 |             this._stashFilter = value;
384 |         }
385 |         else if (value === null) {
386 |             this._stashFilter = defaultStashFilter;
387 |         }
388 |         else {
389 |             throw new Error(`Invalid stash filter: Expected a function.`);
390 |         }
391 |     }
392 |     _initializeWSS(wss) {
393 |         this._wss = wss;
394 |         this._wss.on('connection', (ws) => {
395 |             ws.on('error', (e) => {
396 |                 if (e.code !== "ECONNRESET") {
397 |                     console.log(`WebSocket error: ${e}`);
398 |                 }
399 |             });
400 |             ws.on('message', (message) => __awaiter(this, void 0, void 0, function* () {
401 |                 const original = InterceptedHTTPMessage.FromBuffer(message);
402 |                 const rv = this.cb(original);
403 |                 if (rv && typeof (rv) === 'object' && rv.then) {
404 |                     yield rv;
405 |                 }
406 |                 // Remove transfer-encoding. We don't support chunked.
407 |                 if (this._stashEnabled) {
408 |                     const item = new StashedItem(original.request.rawUrl, original.response.getHeader('content-type'), original.responseBody);
409 |                     if (this._stashFilter(original.request.rawUrl, item)) {
410 |                         this._stash.set(original.request.rawUrl, item);
411 |                     }
412 |                 }
413 |                 ws.send(original.toBuffer());
414 |             }));
415 |         });
416 |     }
417 |     _initializeMITMProxy(mitmProxy) {
418 |         this._mitmProcess = mitmProxy;
419 |         this._mitmProcess.on('exit', (code, signal) => {
420 |             const index = MITMProxy._activeProcesses.indexOf(this._mitmProcess);
421 |             if (index !== -1) {
422 |                 MITMProxy._activeProcesses.splice(index, 1);
423 |             }
424 |             if (code !== null) {
425 |                 if (code !== 0) {
426 |                     this._mitmError = new Error(`Process exited with code ${code}.`);
427 |                 }
428 |             }
429 |             else {
430 |                 this._mitmError = new Error(`Process exited due to signal ${signal}.`);
431 |             }
432 |         });
433 |         this._mitmProcess.on('error', (err) => {
434 |             this._mitmError = err;
435 |         });
436 |     }
437 |     /**
438 |      * Retrieves the given URL from the stash.
439 |      * @param url
440 |      */
441 |     getFromStash(url) {
442 |         return this._stash.get(url);
443 |     }
444 |     forEachStashItem(cb) {
445 |         this._stash.forEach(cb);
446 |     }
447 |     /**
448 |      * Requests the given URL from the proxy.
449 |      */
450 |     proxyGet(urlString) {
451 |         return __awaiter(this, void 0, void 0, function* () {
452 |             const url = url_1.parse(urlString);
453 |             const get = url.protocol === "http:" ? http_1.get : https_1.get;
454 |             return new Promise((resolve, reject) => {
455 |                 const req = get({
456 |                     url: urlString,
457 |                     headers: {
458 |                         host: url.host
459 |                     },
460 |                     host: 'localhost',
461 |                     port: 8080,
462 |                     path: urlString
463 |                 }, (res) => {
464 |                     const data = new Array();
465 |                     res.on('data', (chunk) => {
466 |                         data.push(chunk);
467 |                     });
468 |                     res.on('end', () => {
469 |                         const d = Buffer.concat(data);
470 |                         resolve({
471 |                             statusCode: res.statusCode,
472 |                             headers: res.headers,
473 |                             body: d
474 |                         });
475 |                     });
476 |                     res.once('error', reject);
477 |                 });
478 |                 req.once('error', reject);
479 |             });
480 |         });
481 |     }
482 |     shutdown() {
483 |         return __awaiter(this, void 0, void 0, function* () {
484 |             return new Promise((resolve, reject) => {
485 |                 const closeWSS = () => {
486 |                     this._wss.close((err) => {
487 |                         if (err) {
488 |                             reject(err);
489 |                         }
490 |                         else {
491 |                             resolve();
492 |                         }
493 |                     });
494 |                 };
495 |                 if (this._mitmProcess && !this._mitmProcess.killed) {
496 |                     this._mitmProcess.once('exit', (code, signal) => {
497 |                         closeWSS();
498 |                     });
499 |                     this._mitmProcess.kill('SIGTERM');
500 |                 }
501 |                 else {
502 |                     closeWSS();
503 |                 }
504 |             });
505 |         });
506 |     }
507 | }
508 | MITMProxy._activeProcesses = [];
509 | MITMProxy._cleanupCalled = false;
510 | exports.default = MITMProxy;
511 | //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {Server as WebSocketServer} from 'ws';\nimport {spawn, ChildProcess} from 'child_process';\nimport {resolve} from 'path';\nimport {parse as parseURL, Url} from 'url';\nimport {get as httpGet} from 'http';\nimport {get as httpsGet} from 'https';\nimport {createConnection, Socket} from 'net';\n\n/**\n * Wait for the specified port to open.\n * @param port The port to watch for.\n * @param retries The number of times to retry before giving up. Defaults to 10.\n * @param interval The interval between retries, in milliseconds. Defaults to 500.\n */\nfunction waitForPort(port: number, retries: number = 10, interval: number = 500): Promise<void> {\n  return new Promise<void>((resolve, reject) => {\n    let retriesRemaining = retries;\n    let retryInterval = interval;\n    let timer: NodeJS.Timer = null;\n    let socket: Socket = null;\n\n    function clearTimerAndDestroySocket() {\n      clearTimeout(timer);\n      timer = null;\n      if (socket) socket.destroy();\n      socket = null;\n    }\n\n    function retry() {\n      tryToConnect();\n    }\n\n    function tryToConnect() {\n      clearTimerAndDestroySocket();\n\n      if (--retriesRemaining < 0) {\n        reject(new Error('out of retries'));\n      }\n\n      socket = createConnection(port, \"localhost\", function() {\n        clearTimerAndDestroySocket();\n        if (retriesRemaining >= 0) resolve();\n      });\n\n      timer = setTimeout(function() { retry(); }, retryInterval);\n\n      socket.on('error', function(err) {\n        clearTimerAndDestroySocket();\n        setTimeout(retry, retryInterval);\n      });\n    }\n\n    tryToConnect();\n  });\n}\n\n/**\n * Function that intercepts and rewrites HTTP responses.\n */\nexport type Interceptor = (m: InterceptedHTTPMessage) => void | Promise<void>;\n\n/**\n * An interceptor that does nothing.\n */\nexport function nopInterceptor(m: InterceptedHTTPMessage): void {}\n\n/**\n * The core HTTP response.\n */\nexport interface HTTPResponse {\n  statusCode: number,\n  headers: {[name: string]: string};\n  body: Buffer;\n}\n\n/**\n * Metadata associated with a request/response pair.\n */\ninterface HTTPMessageMetadata {\n  request: HTTPRequestMetadata;\n  response: HTTPResponseMetadata;\n}\n\n/**\n * Metadata associated with an HTTP request.\n */\nexport interface HTTPRequestMetadata {\n  // GET, DELETE, POST,  etc.\n  method: string;\n  // Target URL for the request.\n  url: string;\n  // The set of headers from the request, as key-value pairs.\n  // Since header fields may be repeated, this array may contain multiple entries for the same key.\n  headers: [string, string][];\n}\n\n/**\n * Metadata associated with an HTTP response.\n */\nexport interface HTTPResponseMetadata {\n  // The numerical status code.\n  status_code: number;\n  // The set of headers from the response, as key-value pairs.\n  // Since header fields may be repeated, this array may contain multiple entries for the same key.\n  headers: [string, string][];\n}\n\n/**\n * Abstract class that represents HTTP headers.\n */\nexport abstract class AbstractHTTPHeaders {\n  private _headers: [string, string][];\n  // The raw headers, as a sequence of key/value pairs.\n  // Since header fields may be repeated, this array may contain multiple entries for the same key.\n  public get headers(): [string, string][] {\n    return this._headers;\n  }\n  constructor(headers: [string, string][]) {\n    this._headers = headers;\n  }\n\n  private _indexOfHeader(name: string): number {\n    const headers = this.headers;\n    const len = headers.length;\n    for (let i = 0; i < len; i++) {\n      if (headers[i][0].toLowerCase() === name) {\n        return i;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * Get the value of the given header field.\n   * If there are multiple fields with that name, this only returns the first field's value!\n   * @param name Name of the header field\n   */\n  public getHeader(name: string): string {\n    const index = this._indexOfHeader(name.toLowerCase());\n    if (index !== -1) {\n      return this.headers[index][1];\n    }\n    return '';\n  }\n\n  /**\n   * Set the value of the given header field. Assumes that there is only one field with the given name.\n   * If the field does not exist, it adds a new field with the name and value.\n   * @param name Name of the field.\n   * @param value New value.\n   */\n  public setHeader(name: string, value: string): void {\n    const index = this._indexOfHeader(name.toLowerCase());\n    if (index !== -1) {\n      this.headers[index][1] = value;\n    } else {\n      this.headers.push([name, value]);\n    }\n  }\n\n  /**\n   * Removes the header field with the given name. Assumes that there is only one field with the given name.\n   * Does nothing if field does not exist.\n   * @param name Name of the field.\n   */\n  public removeHeader(name: string): void {\n    const index = this._indexOfHeader(name.toLowerCase());\n    if (index !== -1) {\n      this.headers.splice(index, 1);\n    }\n  }\n\n  /**\n   * Removes all header fields.\n   */\n  public clearHeaders(): void {\n    this._headers = [];\n  }\n}\n\n/**\n * Represents a MITM-ed HTTP response from a server.\n */\nexport class InterceptedHTTPResponse extends AbstractHTTPHeaders {\n  // The status code of the HTTP response.\n  public statusCode: number;\n\n  constructor(metadata: HTTPResponseMetadata) {\n    super(metadata.headers);\n    this.statusCode = metadata.status_code;\n    // We don't support chunked transfers. The proxy already de-chunks it for us.\n    this.removeHeader('transfer-encoding');\n    // MITMProxy decodes the data for us.\n    this.removeHeader('content-encoding');\n    // CSP is bad!\n    this.removeHeader('content-security-policy');\n    this.removeHeader('x-webkit-csp');\n    this.removeHeader('x-content-security-policy');\n  }\n\n  public toJSON(): HTTPResponseMetadata {\n    return {\n      status_code: this.statusCode,\n      headers: this.headers\n    };\n  }\n}\n\n/**\n * Represents an intercepted HTTP request from a client.\n */\nexport class InterceptedHTTPRequest extends AbstractHTTPHeaders {\n  // HTTP method (GET/DELETE/etc)\n  public method: string;\n  // The URL as a string.\n  public rawUrl: string;\n  // The URL as a URL object.\n  public url: Url;\n\n  constructor(metadata: HTTPRequestMetadata) {\n    super(metadata.headers);\n    this.method = metadata.method.toLowerCase();\n    this.rawUrl = metadata.url;\n    this.url = parseURL(this.rawUrl);\n  }\n}\n\n/**\n * Represents an intercepted HTTP request/response pair.\n */\nexport class InterceptedHTTPMessage {\n  /**\n   * Unpack from a Buffer received from MITMProxy.\n   * @param b\n   */\n  public static FromBuffer(b: Buffer): InterceptedHTTPMessage {\n    const metadataSize = b.readInt32LE(0);\n    const requestSize = b.readInt32LE(4);\n    const responseSize = b.readInt32LE(8);\n    const metadata: HTTPMessageMetadata = JSON.parse(b.toString(\"utf8\", 12, 12 + metadataSize));\n    return new InterceptedHTTPMessage(\n      new InterceptedHTTPRequest(metadata.request),\n      new InterceptedHTTPResponse(metadata.response),\n      b.slice(12 + metadataSize, 12 + metadataSize + requestSize),\n      b.slice(12 + metadataSize + requestSize, 12 + metadataSize + requestSize + responseSize)\n    );\n  }\n\n  public readonly request: InterceptedHTTPRequest;\n  public readonly response: InterceptedHTTPResponse;\n  // The body of the HTTP request.\n  public readonly requestBody: Buffer;\n  // The body of the HTTP response. Read-only; change the response body via setResponseBody.\n  public get responseBody(): Buffer {\n    return this._responseBody;\n  }\n  private _responseBody: Buffer;\n  private constructor(request: InterceptedHTTPRequest, response: InterceptedHTTPResponse, requestBody: Buffer, responseBody: Buffer) {\n    this.request = request;\n    this.response = response;\n    this.requestBody = requestBody;\n    this._responseBody = responseBody;\n  }\n\n  /**\n   * Changes the body of the HTTP response. Appropriately updates content-length.\n   * @param b The new body contents.\n   */\n  public setResponseBody(b: Buffer) {\n    this._responseBody = b;\n    // Update content-length.\n    this.response.setHeader('content-length', `${b.length}`);\n    // TODO: Content-encoding?\n  }\n  \n  /**\n   * Changes the status code of the HTTP response.\n   * @param code The new status code.\n   */\n  public setStatusCode(code: number) {\n    this.response.statusCode = code;\n  }\n\n  /**\n   * Pack into a buffer for transmission to MITMProxy.\n   */\n  public toBuffer(): Buffer {\n    const metadata = Buffer.from(JSON.stringify(this.response), 'utf8');\n    const metadataLength = metadata.length;\n    const responseLength = this._responseBody.length\n    const rv = Buffer.alloc(8 + metadataLength + responseLength);\n    rv.writeInt32LE(metadataLength, 0);\n    rv.writeInt32LE(responseLength, 4);\n    metadata.copy(rv, 8);\n    this._responseBody.copy(rv, 8 + metadataLength);\n    return rv;\n  }\n}\n\nexport class StashedItem {\n  constructor(\n    public readonly rawUrl: string,\n    public readonly mimeType: string,\n    public readonly data: Buffer) {}\n\n  public get shortMimeType(): string {\n    let mime = this.mimeType.toLowerCase();\n    if (mime.indexOf(\";\") !== -1) {\n      mime = mime.slice(0, mime.indexOf(\";\"));\n    }\n    return mime;\n  }\n\n  public get isHtml(): boolean {\n    return this.shortMimeType === \"text/html\";\n  }\n\n  public get isJavaScript(): boolean {\n    switch(this.shortMimeType) {\n      case 'text/javascript':\n      case 'application/javascript':\n      case 'text/x-javascript':\n      case 'application/x-javascript':\n        return true;\n      default:\n        return false;\n    }\n  }\n}\n\nfunction defaultStashFilter(url: string, item: StashedItem): boolean {\n  return item.isJavaScript || item.isHtml;\n}\n\n/**\n * Class that launches MITM proxy and talks to it via WebSockets.\n */\nexport default class MITMProxy {\n  private static _activeProcesses: ChildProcess[] = [];\n\n  /**\n   * Creates a new MITMProxy instance.\n   * @param cb Called with intercepted HTTP requests / responses.\n   * @param interceptPaths List of paths to completely intercept without sending to the server (e.g. ['/eval'])\n   * @param quiet If true, do not print debugging messages (defaults to 'true').\n   * @param onlyInterceptTextFiles If true, only intercept text files (JavaScript/HTML/CSS/etc, and ignore media files).\n   */\n  public static async Create(cb: Interceptor = nopInterceptor, interceptPaths: string[] = [], quiet: boolean = true, onlyInterceptTextFiles = false, ignoreHosts: string | null = null): Promise<MITMProxy> {\n    // Construct WebSocket server, and wait for it to begin listening.\n    const wss = new WebSocketServer({ port: 8765 });\n    const proxyConnected = new Promise<void>((resolve, reject) => {\n      wss.once('connection', () => {\n        resolve();\n      });\n    });\n    const mp = new MITMProxy(cb, onlyInterceptTextFiles);\n    // Set up WSS callbacks before MITMProxy connects.\n    mp._initializeWSS(wss);\n    await new Promise<void>((resolve, reject) => {\n      wss.once('listening', () => {\n        wss.removeListener('error', reject);\n        resolve();\n      });\n      wss.once('error', reject);\n    });\n\n    try {\n      try {\n        await waitForPort(8080, 1);\n        if (!quiet) {\n          console.log(`MITMProxy already running.`);\n        }\n      } catch (e) {\n        if (!quiet) {\n          console.log(`MITMProxy not running; starting up mitmproxy.`);\n        }\n        // Start up MITM process.\n        // --anticache means to disable caching, which gets in the way of transparently rewriting content.\n        const scriptArgs = interceptPaths.length > 0 ? [\"--set\", `intercept=${interceptPaths.join(\",\")}`] : [];\n        scriptArgs.push(\"--set\", `onlyInterceptTextFiles=${onlyInterceptTextFiles}`);\n        if (ignoreHosts) {\n          scriptArgs.push(`--ignore-hosts`, ignoreHosts);\n        }\n\n        const options = [\"--anticache\", \"-s\", resolve(__dirname, `../scripts/proxy.py`)].concat(scriptArgs);\n        if (quiet) {\n          options.push('-q');\n        }\n        \n        // allow self-signed SSL certificates\n        options.push(\"--ssl-insecure\");\n        \n        const mitmProcess = spawn(\"mitmdump\", options, {\n          stdio: 'inherit'\n        });\n        const mitmProxyExited = new Promise<void>((_, reject) => {\n          mitmProcess.once('error', reject);\n          mitmProcess.once('exit', reject);\n        });\n        if (MITMProxy._activeProcesses.push(mitmProcess) === 1) {\n          process.on('SIGINT', MITMProxy._cleanup);\n          process.on('exit', MITMProxy._cleanup);\n        }\n        mp._initializeMITMProxy(mitmProcess);\n        // Wait for port 8080 to come online.\n        const waitingForPort = waitForPort(8080);\n        try {\n          // Fails if mitmproxy exits before port becomes available.\n          await Promise.race([mitmProxyExited, waitingForPort]);\n        } catch (e) {\n          if (e && typeof(e) === 'object' && e.code === \"ENOENT\") {\n            throw new Error(`mitmdump, which is an executable that ships with mitmproxy, is not on your PATH. Please ensure that you can run mitmdump --version successfully from your command line.`)\n          } else {\n            throw new Error(`Unable to start mitmproxy: ${e}`);\n          }\n        }\n      }\n      await proxyConnected;\n    } catch (e) {\n      await new Promise<any>((resolve) => wss.close(resolve));\n      throw e;\n    }\n\n    return mp;\n  }\n\n  private static _cleanupCalled = false;\n  private static _cleanup(): void {\n    if (MITMProxy._cleanupCalled) {\n      return;\n    }\n    MITMProxy._cleanupCalled = true;\n    MITMProxy._activeProcesses.forEach((p) => {\n      p.kill('SIGKILL');\n    });\n  }\n\n  private _stashEnabled: boolean = false;\n  // Toggle whether or not mitmproxy-node stashes modified server responses.\n  // **Not used for performance**, but enables Node.js code to fetch previous server responses from the proxy.\n  public get stashEnabled(): boolean {\n    return this._stashEnabled;\n  }\n  public set stashEnabled(v: boolean) {\n    if (!v) {\n      this._stash.clear();\n    }\n    this._stashEnabled = v;\n  }\n  private _mitmProcess: ChildProcess = null;\n  private _mitmError: Error = null;\n  private _wss: WebSocketServer = null;\n  public cb: Interceptor;\n  public readonly onlyInterceptTextFiles: boolean;\n  private _stash = new Map<string, StashedItem>();\n  private _stashFilter: (url: string, item: StashedItem) => boolean = defaultStashFilter;\n  public get stashFilter(): (url: string, item: StashedItem) => boolean {\n    return this._stashFilter;\n  }\n  public set stashFilter(value: (url: string, item: StashedItem) => boolean) {\n    if (typeof(value) === 'function') {\n      this._stashFilter = value;\n    } else if (value === null) {\n      this._stashFilter = defaultStashFilter;\n    } else {\n      throw new Error(`Invalid stash filter: Expected a function.`);\n    }\n  }\n\n  private constructor(cb: Interceptor, onlyInterceptTextFiles: boolean) {\n    this.cb = cb;\n    this.onlyInterceptTextFiles = onlyInterceptTextFiles;\n  }\n\n  private _initializeWSS(wss: WebSocketServer): void {\n    this._wss = wss;\n    this._wss.on('connection', (ws) => {\n      ws.on('error', (e) => {\n        if ((e as any).code !== \"ECONNRESET\") {\n          console.log(`WebSocket error: ${e}`);\n        }\n      });\n      ws.on('message', async (message: Buffer) => {\n        const original = InterceptedHTTPMessage.FromBuffer(message);\n        const rv = this.cb(original);\n        if (rv && typeof(rv) === 'object' && rv.then) {\n          await rv;\n        }\n        // Remove transfer-encoding. We don't support chunked.\n        if (this._stashEnabled) {\n          const item = new StashedItem(original.request.rawUrl, original.response.getHeader('content-type'), original.responseBody);\n          if (this._stashFilter(original.request.rawUrl, item)) {\n            this._stash.set(original.request.rawUrl, item);\n          }\n        }\n        ws.send(original.toBuffer());\n      });\n    });\n  }\n\n  private _initializeMITMProxy(mitmProxy: ChildProcess): void {\n    this._mitmProcess = mitmProxy;\n    this._mitmProcess.on('exit', (code, signal) => {\n      const index = MITMProxy._activeProcesses.indexOf(this._mitmProcess);\n      if (index !== -1) {\n        MITMProxy._activeProcesses.splice(index, 1);\n      }\n      if (code !== null) {\n        if (code !== 0) {\n          this._mitmError = new Error(`Process exited with code ${code}.`);\n        }\n      } else {\n        this._mitmError = new Error(`Process exited due to signal ${signal}.`);\n      }\n    });\n    this._mitmProcess.on('error', (err) => {\n      this._mitmError = err;\n    });\n  }\n\n  /**\n   * Retrieves the given URL from the stash.\n   * @param url\n   */\n  public getFromStash(url: string): StashedItem {\n    return this._stash.get(url);\n  }\n\n  public forEachStashItem(cb: (value: StashedItem, url: string) => void): void {\n    this._stash.forEach(cb);\n  }\n\n  /**\n   * Requests the given URL from the proxy.\n   */\n  public async proxyGet(urlString: string): Promise<HTTPResponse> {\n    const url = parseURL(urlString);\n    const get = url.protocol === \"http:\" ? httpGet : httpsGet;\n    return new Promise<HTTPResponse>((resolve, reject) => {\n      const req = get({\n        url: urlString,\n        headers: {\n          host: url.host\n        },\n        host: 'localhost',\n        port: 8080,\n        path: urlString\n      }, (res) => {\n        const data = new Array<Buffer>();\n        res.on('data', (chunk: Buffer) => {\n          data.push(chunk);\n        });\n        res.on('end', () => {\n          const d = Buffer.concat(data);\n          resolve({\n            statusCode: res.statusCode,\n            headers: res.headers,\n            body: d\n          } as HTTPResponse);\n        });\n        res.once('error', reject);\n      });\n      req.once('error', reject);\n    });\n  }\n\n  public async shutdown(): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n      const closeWSS = () => {\n        this._wss.close((err) => {\n          if (err) {\n            reject(err);\n          } else {\n            resolve();\n          }\n        });\n      };\n\n      if (this._mitmProcess && !this._mitmProcess.killed) {\n        this._mitmProcess.once('exit', (code, signal) => {\n          closeWSS();\n        });\n        this._mitmProcess.kill('SIGTERM');\n      } else {\n        closeWSS();\n      }\n    });\n  }\n}\n"]}


--------------------------------------------------------------------------------
/package-lock.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "mitmproxy",
 3 |   "version": "2.1.2",
 4 |   "lockfileVersion": 1,
 5 |   "requires": true,
 6 |   "dependencies": {
 7 |     "@types/node": {
 8 |       "version": "7.0.44",
 9 |       "resolved": "https://registry.npmjs.org/@types/node/-/node-7.0.44.tgz",
10 |       "integrity": "sha512-5ZskbOk+/EIZErNRo8bgemhtw99PB+CsdOm2wM5qAgc+MwAVL6L9RZv2Hin7Y8S7FewCkPqNlw+3hTmT+PsnJA=="
11 |     },
12 |     "@types/ws": {
13 |       "version": "3.2.0",
14 |       "resolved": "https://registry.npmjs.org/@types/ws/-/ws-3.2.0.tgz",
15 |       "integrity": "sha512-XehU2SdII5wu7EUV1bAwCoTDZYZCCU7Es7gbHtJjGXq6Bs2AI4HuJ//wvPrVuuYwkkZseQzDUxsZF8Urnb3I1A==",
16 |       "requires": {
17 |         "@types/node": "*"
18 |       }
19 |     },
20 |     "async-limiter": {
21 |       "version": "1.0.0",
22 |       "resolved": "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.0.tgz",
23 |       "integrity": "sha512-jp/uFnooOiO+L211eZOoSyzpOITMXx1rBITauYykG3BRYPu8h0UcxsPNB04RR5vo4Tyz3+ay17tR6JVf9qzYWg=="
24 |     },
25 |     "safe-buffer": {
26 |       "version": "5.1.1",
27 |       "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz",
28 |       "integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg=="
29 |     },
30 |     "typescript": {
31 |       "version": "2.5.3",
32 |       "resolved": "https://registry.npmjs.org/typescript/-/typescript-2.5.3.tgz",
33 |       "integrity": "sha512-ptLSQs2S4QuS6/OD1eAKG+S5G8QQtrU5RT32JULdZQtM1L3WTi34Wsu48Yndzi8xsObRAB9RPt/KhA9wlpEF6w==",
34 |       "dev": true
35 |     },
36 |     "ultron": {
37 |       "version": "1.1.0",
38 |       "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.1.0.tgz",
39 |       "integrity": "sha1-sHoualQagV/Go0zNRTO67DB8qGQ="
40 |     },
41 |     "ws": {
42 |       "version": "3.2.0",
43 |       "resolved": "https://registry.npmjs.org/ws/-/ws-3.2.0.tgz",
44 |       "integrity": "sha512-hTS3mkXm/j85jTQOIcwVz3yK3up9xHgPtgEhDBOH3G18LDOZmSAG1omJeXejLKJakx+okv8vS1sopgs7rw0kVw==",
45 |       "requires": {
46 |         "async-limiter": "~1.0.0",
47 |         "safe-buffer": "~5.1.0",
48 |         "ultron": "~1.1.0"
49 |       }
50 |     }
51 |   }
52 | }
53 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "mitmproxy",
 3 |   "version": "2.1.2",
 4 |   "description": "NodeJS mitmproxy adapter.",
 5 |   "main": "dist/index.js",
 6 |   "types": "dist/index.d.ts",
 7 |   "scripts": {
 8 |     "build": "tsc",
 9 |     "watch": "tsc -w",
10 |     "postinstall": "node scripts/install_python_deps.js",
11 |     "prepare": "tsc"
12 |   },
13 |   "repository": {
14 |     "type": "git",
15 |     "url": "https://github.com/jvilk/mitmproxy-node.git"
16 |   },
17 |   "keywords": [
18 |     "proxy",
19 |     "mitm",
20 |     "rewriting",
21 |     "man-in-the-middle",
22 |     "transparent"
23 |   ],
24 |   "author": "John Vilk <jvilk@jvilk.com>",
25 |   "license": "MIT",
26 |   "homepage": "https://github.com/jvilk/mitmproxy-node",
27 |   "dependencies": {
28 |     "@types/node": "^7.0.44",
29 |     "@types/ws": "^3.2.0",
30 |     "ws": "^3.2.0"
31 |   },
32 |   "devDependencies": {
33 |     "typescript": "^2.5.3"
34 |   }
35 | }
36 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | websockets==6.0.0


--------------------------------------------------------------------------------
/scripts/install_python_deps.js:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env node
 2 | 
 3 | const child_process = require('child_process');
 4 | 
 5 | const result = child_process.spawnSync("python3", ["scripts/install_python_deps.py"], {stdio: "inherit"});
 6 | if (result.error && result.error.code === "ENOENT") {
 7 |   const result2 = child_process.spawnSync("python", ["scripts/install_python_deps.py"], {stdio: "inherit"});
 8 |   if (result2.error) {
 9 |     console.log("Failed to run python3 or python: ");
10 |     console.log(result.error);
11 |     console.log(result2.error);
12 |   }
13 | }
14 | 


--------------------------------------------------------------------------------
/scripts/install_python_deps.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | """
 3 | Sanity checks the Python environment
 4 | """
 5 | import sys
 6 | from subprocess import check_call, check_output
 7 | 
 8 | # Check Python version
 9 | if sys.version_info < (3,6):
10 |     sys.exit("mitmproxy-node requires a Python version >= 3.6, but found {}.{}".format(sys.version_info[0], sys.version_info[1]))
11 | 
12 | # Verify that mitmproxy is installed
13 | try:
14 |     mitmdump_output = str(check_output(["mitmdump", "--version"]))
15 |     version = mitmdump_output.split("\\n")[0].split(" ")[1].split('.')
16 |     print(version)
17 |     version[0] = int(version[0])
18 |     version[1] = int(version[1])
19 |     version[2] = int(version[2])
20 |     if tuple(version) < (4,0,0):
21 |         sys.exit("mitmproxy-node requires mitmproxy >= 4.0.0, but found {}.{}.{}".format(version[0], version[1], version[2]))
22 | except FileNotFoundError:
23 |     sys.exit("mitmproxy-node requires mitmproxy to be installed. See http://docs.mitmproxy.org/en/stable/install.html for instructions.")
24 | 
25 | # Install dependencies with pip3 first.
26 | # If pip3 isn't found, use pip.
27 | try:
28 |     check_call(["pip3", "install", "-r", "requirements.txt"])
29 | except FileNotFoundError:
30 |     check_call(["pip", "install", "-r", "requirements.txt"])
31 | 


--------------------------------------------------------------------------------
/scripts/proxy.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | """
  3 | Interception proxy using mitmproxy (https://mitmproxy.org).
  4 | Communicates to NodeJS via websockets.
  5 | """
  6 | 
  7 | import argparse
  8 | import asyncio
  9 | import queue
 10 | import json
 11 | import threading
 12 | import typing
 13 | import traceback
 14 | import sys
 15 | import struct
 16 | import websockets
 17 | from mitmproxy import ctx
 18 | from mitmproxy import http
 19 | 
 20 | def convert_headers_to_bytes(header_entry):
 21 |     """
 22 |     Converts a tuple of strings into a tuple of bytes.
 23 |     """
 24 |     return [bytes(header_entry[0], "utf8"), bytes(header_entry[1], "utf8")]
 25 | 
 26 | def convert_body_to_bytes(body):
 27 |     """
 28 |     Converts a HTTP request/response body into a list of numbers.
 29 |     """
 30 |     if body is None:
 31 |         return bytes()
 32 |     else:
 33 |         return body
 34 | 
 35 | def is_text_response(headers):
 36 |     if 'content-type' in headers:
 37 |         ct = headers['content-type'].lower()
 38 |         # Allow all application/ and text/ MIME types.
 39 |         return 'application' in ct or 'text' in ct or ct.strip() == ""
 40 |     return True
 41 | 
 42 | class WebSocketAdapter:
 43 |     """
 44 |     Relays HTTP/HTTPS requests to a websocket server.
 45 |     Enables using MITMProxy from outside of Python.
 46 |     """
 47 | 
 48 |     def websocket_thread(self):
 49 |         """
 50 |         Main function of the websocket thread. Runs the websocket event loop
 51 |         until MITMProxy shuts down.
 52 |         """
 53 |         self.worker_event_loop = asyncio.new_event_loop()
 54 |         self.worker_event_loop.run_until_complete(self.websocket_loop())
 55 | 
 56 |     def __init__(self):
 57 |         self.queue = queue.Queue()
 58 |         self.intercept_paths = frozenset([])
 59 |         self.only_intercept_text_files = False
 60 |         self.finished = False
 61 |         # Start websocket thread
 62 |         threading.Thread(target=self.websocket_thread).start()
 63 | 
 64 |     def load(self, loader):
 65 |         loader.add_option(
 66 |             "intercept", str, "",
 67 |             """
 68 |             A list of HTTP paths, delimited by a comma, to intercept and pass to Node without hitting the server.
 69 |             E.g.: /foo,/bar
 70 |             """
 71 |         )
 72 |         loader.add_option(
 73 |             name = "onlyInterceptTextFiles",
 74 |             typespec = bool,
 75 |             default = False,
 76 |             help = "If true, the plugin only intercepts text files and passes through other types of files",
 77 |         )
 78 |         return
 79 | 
 80 |     def configure(self, updates):
 81 |         if "intercept" in updates:
 82 |             self.intercept_paths = frozenset(ctx.options.intercept.split(","))
 83 |             #print("Intercept paths:")
 84 |             #print(self.intercept_paths)
 85 |         if "onlyInterceptTextFiles" in updates:
 86 |             self.only_intercept_text_files = ctx.options.onlyInterceptTextFiles
 87 |             #print("Only intercept text files:")
 88 |             #print(self.only_intercept_text_files)
 89 |         return
 90 | 
 91 |     def send_message(self, metadata, data1, data2):
 92 |         """
 93 |         Sends the given message on the WebSocket connection,
 94 |         and awaits a response. Metadata is a JSONable object,
 95 |         and data is bytes.
 96 |         """
 97 |         metadata_bytes = bytes(json.dumps(metadata), 'utf8')
 98 |         data1_size = len(data1)
 99 |         data2_size = len(data2)
100 |         metadata_size = len(metadata_bytes)
101 |         msg = struct.pack("<III" + str(metadata_size) + "s" +
102 |                           str(data1_size) + "s" + str(data2_size) + "s",
103 |                           metadata_size, data1_size, data2_size, metadata_bytes, data1, data2)
104 |         obj = {
105 |             'lock': threading.Condition(),
106 |             'msg': msg,
107 |             'response': None
108 |         }
109 |         # We use the lock to marry multithreading with asyncio.
110 |         #print("acquiring lock")
111 |         obj['lock'].acquire()
112 |         #print("inserting into list")
113 |         self.queue.put(obj)
114 |         #print("waiting")
115 |         obj['lock'].wait()
116 |         #print("wait finished!")
117 |         new_response = obj['response']
118 |         if new_response is None:
119 |             # Never got a response / an error occurred
120 |             return None
121 | 
122 |         new_response_size = len(new_response)
123 |         all_data = struct.unpack("<II" + str(new_response_size - 8) + "s", new_response)
124 | 
125 |         return (json.loads(all_data[2][0:all_data[0]]), all_data[2][all_data[0]:])
126 | 
127 |     def request(self, flow):
128 |         """
129 |         Intercepts an HTTP request. If the proxy is configured to intercept the path, then
130 |         do so without sending to the server.
131 |         """
132 |         if flow.request.path in self.intercept_paths:
133 |             request = flow.request
134 |             message_response = self.send_message({
135 |                 'request': {
136 |                     'method': request.method,
137 |                     'url': request.url,
138 |                     'headers': list(request.headers.items(True))
139 |                 },
140 |                 'response': {
141 |                     'status_code': 200,
142 |                     'headers': list()
143 |                 }
144 |             }, convert_body_to_bytes(request.content), convert_body_to_bytes(None))
145 |             if message_response is None:
146 |                 # No response received; making no modifications.
147 |                 return
148 |             new_metadata = message_response[0]
149 |             new_body = message_response[1]
150 | 
151 |             flow.response = http.HTTPResponse.make(
152 |                 new_metadata['status_code'],
153 |                 new_body,
154 |                 map(convert_headers_to_bytes, new_metadata['headers'])
155 |             )
156 |         return
157 | 
158 |     def responseheaders(self, flow):
159 |         # Stream all non-text responses if only_intercept_text_files is enabled.
160 |         # Do not stream intercepted paths.
161 |         flow.response.stream = flow.request.path not in self.intercept_paths and self.only_intercept_text_files and not is_text_response(flow.response.headers)
162 | 
163 |     def response(self, flow):
164 |         """
165 |         Intercepts an HTTP response. Mutates its headers / body / status code / etc.
166 |         """
167 |         # Streaming responses are things we said to stream in responseheaders
168 |         if flow.response.stream:
169 |             return
170 | 
171 |         request = flow.request
172 | 
173 |         # Ignore intercepted paths
174 |         if request.path in self.intercept_paths:
175 |             return
176 |         response = flow.response
177 |         message_response = self.send_message({
178 |             'request': {
179 |                 'method': request.method,
180 |                 'url': request.url,
181 |                 'headers': list(request.headers.items(True)),
182 |             },
183 |             'response': {
184 |                 'status_code': response.status_code,
185 |                 'headers': list(response.headers.items(True)),
186 |             }
187 |         }, convert_body_to_bytes(request.content), convert_body_to_bytes(response.content))
188 | 
189 |         if message_response is None:
190 |             # No response received; making no modifications.
191 |             return
192 | 
193 |         new_metadata = message_response[0]
194 |         new_body = message_response[1]
195 | 
196 | 
197 |         #print("Prepping response!")
198 | 
199 |         flow.response = http.HTTPResponse.make(
200 |             new_metadata['status_code'],
201 |             new_body,
202 |             map(convert_headers_to_bytes, new_metadata['headers'])
203 |         )
204 |         return
205 | 
206 |     def done(self):
207 |         """
208 |         Called when MITMProxy is shutting down.
209 |         """
210 |         # Tell the WebSocket loop to stop processing events
211 |         self.finished = True
212 |         self.queue.put(None)
213 |         return
214 | 
215 |     async def websocket_loop(self):
216 |         """
217 |         Processes messages from self.queue until mitmproxy shuts us down.
218 |         """
219 |         while not self.finished:
220 |             try:
221 |                 async with websockets.connect('ws://localhost:8765', max_size = None) as websocket:
222 |                     while True:
223 |                         # Make sure connection is still live.
224 |                         await websocket.ping()
225 |                         try:
226 |                             obj = self.queue.get(timeout=1)
227 |                             if obj is None:
228 |                                 break
229 |                             try:
230 |                                 obj['lock'].acquire()
231 |                                 await websocket.send(obj['msg'])
232 |                                 obj['response'] = await websocket.recv()
233 |                             finally:
234 |                                 # Always remember to wake up other thread + release lock to avoid deadlocks
235 |                                 obj['lock'].notify()
236 |                                 obj['lock'].release()
237 |                         except queue.Empty:
238 |                             pass
239 |             except websockets.exceptions.ConnectionClosed:
240 |                 # disconnected from server
241 |                 pass
242 |             except BrokenPipeError:
243 |                 # Connect failed
244 |                 pass
245 |             except IOError:
246 |                 # disconnected from server mis-transfer
247 |                 pass
248 |             except:
249 |                 print("[mitmproxy-node plugin] Unexpected error:", sys.exc_info())
250 |                 traceback.print_exc(file=sys.stdout)
251 | 
252 | addons = [
253 |     WebSocketAdapter()
254 | ]
255 | 


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
  1 | import {Server as WebSocketServer} from 'ws';
  2 | import {spawn, ChildProcess} from 'child_process';
  3 | import {resolve} from 'path';
  4 | import {parse as parseURL, Url} from 'url';
  5 | import {get as httpGet} from 'http';
  6 | import {get as httpsGet} from 'https';
  7 | import {createConnection, Socket} from 'net';
  8 | 
  9 | /**
 10 |  * Wait for the specified port to open.
 11 |  * @param port The port to watch for.
 12 |  * @param retries The number of times to retry before giving up. Defaults to 10.
 13 |  * @param interval The interval between retries, in milliseconds. Defaults to 500.
 14 |  */
 15 | function waitForPort(port: number, retries: number = 10, interval: number = 500): Promise<void> {
 16 |   return new Promise<void>((resolve, reject) => {
 17 |     let retriesRemaining = retries;
 18 |     let retryInterval = interval;
 19 |     let timer: NodeJS.Timer = null;
 20 |     let socket: Socket = null;
 21 | 
 22 |     function clearTimerAndDestroySocket() {
 23 |       clearTimeout(timer);
 24 |       timer = null;
 25 |       if (socket) socket.destroy();
 26 |       socket = null;
 27 |     }
 28 | 
 29 |     function retry() {
 30 |       tryToConnect();
 31 |     }
 32 | 
 33 |     function tryToConnect() {
 34 |       clearTimerAndDestroySocket();
 35 | 
 36 |       if (--retriesRemaining < 0) {
 37 |         reject(new Error('out of retries'));
 38 |       }
 39 | 
 40 |       socket = createConnection(port, "localhost", function() {
 41 |         clearTimerAndDestroySocket();
 42 |         if (retriesRemaining >= 0) resolve();
 43 |       });
 44 | 
 45 |       timer = setTimeout(function() { retry(); }, retryInterval);
 46 | 
 47 |       socket.on('error', function(err) {
 48 |         clearTimerAndDestroySocket();
 49 |         setTimeout(retry, retryInterval);
 50 |       });
 51 |     }
 52 | 
 53 |     tryToConnect();
 54 |   });
 55 | }
 56 | 
 57 | /**
 58 |  * Function that intercepts and rewrites HTTP responses.
 59 |  */
 60 | export type Interceptor = (m: InterceptedHTTPMessage) => void | Promise<void>;
 61 | 
 62 | /**
 63 |  * An interceptor that does nothing.
 64 |  */
 65 | export function nopInterceptor(m: InterceptedHTTPMessage): void {}
 66 | 
 67 | /**
 68 |  * The core HTTP response.
 69 |  */
 70 | export interface HTTPResponse {
 71 |   statusCode: number,
 72 |   headers: {[name: string]: string};
 73 |   body: Buffer;
 74 | }
 75 | 
 76 | /**
 77 |  * Metadata associated with a request/response pair.
 78 |  */
 79 | interface HTTPMessageMetadata {
 80 |   request: HTTPRequestMetadata;
 81 |   response: HTTPResponseMetadata;
 82 | }
 83 | 
 84 | /**
 85 |  * Metadata associated with an HTTP request.
 86 |  */
 87 | export interface HTTPRequestMetadata {
 88 |   // GET, DELETE, POST,  etc.
 89 |   method: string;
 90 |   // Target URL for the request.
 91 |   url: string;
 92 |   // The set of headers from the request, as key-value pairs.
 93 |   // Since header fields may be repeated, this array may contain multiple entries for the same key.
 94 |   headers: [string, string][];
 95 | }
 96 | 
 97 | /**
 98 |  * Metadata associated with an HTTP response.
 99 |  */
100 | export interface HTTPResponseMetadata {
101 |   // The numerical status code.
102 |   status_code: number;
103 |   // The set of headers from the response, as key-value pairs.
104 |   // Since header fields may be repeated, this array may contain multiple entries for the same key.
105 |   headers: [string, string][];
106 | }
107 | 
108 | /**
109 |  * Abstract class that represents HTTP headers.
110 |  */
111 | export abstract class AbstractHTTPHeaders {
112 |   private _headers: [string, string][];
113 |   // The raw headers, as a sequence of key/value pairs.
114 |   // Since header fields may be repeated, this array may contain multiple entries for the same key.
115 |   public get headers(): [string, string][] {
116 |     return this._headers;
117 |   }
118 |   constructor(headers: [string, string][]) {
119 |     this._headers = headers;
120 |   }
121 | 
122 |   private _indexOfHeader(name: string): number {
123 |     const headers = this.headers;
124 |     const len = headers.length;
125 |     for (let i = 0; i < len; i++) {
126 |       if (headers[i][0].toLowerCase() === name) {
127 |         return i;
128 |       }
129 |     }
130 |     return -1;
131 |   }
132 | 
133 |   /**
134 |    * Get the value of the given header field.
135 |    * If there are multiple fields with that name, this only returns the first field's value!
136 |    * @param name Name of the header field
137 |    */
138 |   public getHeader(name: string): string {
139 |     const index = this._indexOfHeader(name.toLowerCase());
140 |     if (index !== -1) {
141 |       return this.headers[index][1];
142 |     }
143 |     return '';
144 |   }
145 | 
146 |   /**
147 |    * Set the value of the given header field. Assumes that there is only one field with the given name.
148 |    * If the field does not exist, it adds a new field with the name and value.
149 |    * @param name Name of the field.
150 |    * @param value New value.
151 |    */
152 |   public setHeader(name: string, value: string): void {
153 |     const index = this._indexOfHeader(name.toLowerCase());
154 |     if (index !== -1) {
155 |       this.headers[index][1] = value;
156 |     } else {
157 |       this.headers.push([name, value]);
158 |     }
159 |   }
160 | 
161 |   /**
162 |    * Removes the header field with the given name. Assumes that there is only one field with the given name.
163 |    * Does nothing if field does not exist.
164 |    * @param name Name of the field.
165 |    */
166 |   public removeHeader(name: string): void {
167 |     const index = this._indexOfHeader(name.toLowerCase());
168 |     if (index !== -1) {
169 |       this.headers.splice(index, 1);
170 |     }
171 |   }
172 | 
173 |   /**
174 |    * Removes all header fields.
175 |    */
176 |   public clearHeaders(): void {
177 |     this._headers = [];
178 |   }
179 | }
180 | 
181 | /**
182 |  * Represents a MITM-ed HTTP response from a server.
183 |  */
184 | export class InterceptedHTTPResponse extends AbstractHTTPHeaders {
185 |   // The status code of the HTTP response.
186 |   public statusCode: number;
187 | 
188 |   constructor(metadata: HTTPResponseMetadata) {
189 |     super(metadata.headers);
190 |     this.statusCode = metadata.status_code;
191 |     // We don't support chunked transfers. The proxy already de-chunks it for us.
192 |     this.removeHeader('transfer-encoding');
193 |     // MITMProxy decodes the data for us.
194 |     this.removeHeader('content-encoding');
195 |     // CSP is bad!
196 |     this.removeHeader('content-security-policy');
197 |     this.removeHeader('x-webkit-csp');
198 |     this.removeHeader('x-content-security-policy');
199 |   }
200 | 
201 |   public toJSON(): HTTPResponseMetadata {
202 |     return {
203 |       status_code: this.statusCode,
204 |       headers: this.headers
205 |     };
206 |   }
207 | }
208 | 
209 | /**
210 |  * Represents an intercepted HTTP request from a client.
211 |  */
212 | export class InterceptedHTTPRequest extends AbstractHTTPHeaders {
213 |   // HTTP method (GET/DELETE/etc)
214 |   public method: string;
215 |   // The URL as a string.
216 |   public rawUrl: string;
217 |   // The URL as a URL object.
218 |   public url: Url;
219 | 
220 |   constructor(metadata: HTTPRequestMetadata) {
221 |     super(metadata.headers);
222 |     this.method = metadata.method.toLowerCase();
223 |     this.rawUrl = metadata.url;
224 |     this.url = parseURL(this.rawUrl);
225 |   }
226 | }
227 | 
228 | /**
229 |  * Represents an intercepted HTTP request/response pair.
230 |  */
231 | export class InterceptedHTTPMessage {
232 |   /**
233 |    * Unpack from a Buffer received from MITMProxy.
234 |    * @param b
235 |    */
236 |   public static FromBuffer(b: Buffer): InterceptedHTTPMessage {
237 |     const metadataSize = b.readInt32LE(0);
238 |     const requestSize = b.readInt32LE(4);
239 |     const responseSize = b.readInt32LE(8);
240 |     const metadata: HTTPMessageMetadata = JSON.parse(b.toString("utf8", 12, 12 + metadataSize));
241 |     return new InterceptedHTTPMessage(
242 |       new InterceptedHTTPRequest(metadata.request),
243 |       new InterceptedHTTPResponse(metadata.response),
244 |       b.slice(12 + metadataSize, 12 + metadataSize + requestSize),
245 |       b.slice(12 + metadataSize + requestSize, 12 + metadataSize + requestSize + responseSize)
246 |     );
247 |   }
248 | 
249 |   public readonly request: InterceptedHTTPRequest;
250 |   public readonly response: InterceptedHTTPResponse;
251 |   // The body of the HTTP request.
252 |   public readonly requestBody: Buffer;
253 |   // The body of the HTTP response. Read-only; change the response body via setResponseBody.
254 |   public get responseBody(): Buffer {
255 |     return this._responseBody;
256 |   }
257 |   private _responseBody: Buffer;
258 |   private constructor(request: InterceptedHTTPRequest, response: InterceptedHTTPResponse, requestBody: Buffer, responseBody: Buffer) {
259 |     this.request = request;
260 |     this.response = response;
261 |     this.requestBody = requestBody;
262 |     this._responseBody = responseBody;
263 |   }
264 | 
265 |   /**
266 |    * Changes the body of the HTTP response. Appropriately updates content-length.
267 |    * @param b The new body contents.
268 |    */
269 |   public setResponseBody(b: Buffer) {
270 |     this._responseBody = b;
271 |     // Update content-length.
272 |     this.response.setHeader('content-length', `${b.length}`);
273 |     // TODO: Content-encoding?
274 |   }
275 |   
276 |   /**
277 |    * Changes the status code of the HTTP response.
278 |    * @param code The new status code.
279 |    */
280 |   public setStatusCode(code: number) {
281 |     this.response.statusCode = code;
282 |   }
283 | 
284 |   /**
285 |    * Pack into a buffer for transmission to MITMProxy.
286 |    */
287 |   public toBuffer(): Buffer {
288 |     const metadata = Buffer.from(JSON.stringify(this.response), 'utf8');
289 |     const metadataLength = metadata.length;
290 |     const responseLength = this._responseBody.length
291 |     const rv = Buffer.alloc(8 + metadataLength + responseLength);
292 |     rv.writeInt32LE(metadataLength, 0);
293 |     rv.writeInt32LE(responseLength, 4);
294 |     metadata.copy(rv, 8);
295 |     this._responseBody.copy(rv, 8 + metadataLength);
296 |     return rv;
297 |   }
298 | }
299 | 
300 | export class StashedItem {
301 |   constructor(
302 |     public readonly rawUrl: string,
303 |     public readonly mimeType: string,
304 |     public readonly data: Buffer) {}
305 | 
306 |   public get shortMimeType(): string {
307 |     let mime = this.mimeType.toLowerCase();
308 |     if (mime.indexOf(";") !== -1) {
309 |       mime = mime.slice(0, mime.indexOf(";"));
310 |     }
311 |     return mime;
312 |   }
313 | 
314 |   public get isHtml(): boolean {
315 |     return this.shortMimeType === "text/html";
316 |   }
317 | 
318 |   public get isJavaScript(): boolean {
319 |     switch(this.shortMimeType) {
320 |       case 'text/javascript':
321 |       case 'application/javascript':
322 |       case 'text/x-javascript':
323 |       case 'application/x-javascript':
324 |         return true;
325 |       default:
326 |         return false;
327 |     }
328 |   }
329 | }
330 | 
331 | function defaultStashFilter(url: string, item: StashedItem): boolean {
332 |   return item.isJavaScript || item.isHtml;
333 | }
334 | 
335 | /**
336 |  * Class that launches MITM proxy and talks to it via WebSockets.
337 |  */
338 | export default class MITMProxy {
339 |   private static _activeProcesses: ChildProcess[] = [];
340 | 
341 |   /**
342 |    * Creates a new MITMProxy instance.
343 |    * @param cb Called with intercepted HTTP requests / responses.
344 |    * @param interceptPaths List of paths to completely intercept without sending to the server (e.g. ['/eval'])
345 |    * @param quiet If true, do not print debugging messages (defaults to 'true').
346 |    * @param onlyInterceptTextFiles If true, only intercept text files (JavaScript/HTML/CSS/etc, and ignore media files).
347 |    */
348 |   public static async Create(cb: Interceptor = nopInterceptor, interceptPaths: string[] = [], quiet: boolean = true, onlyInterceptTextFiles = false, ignoreHosts: string | null = null): Promise<MITMProxy> {
349 |     // Construct WebSocket server, and wait for it to begin listening.
350 |     const wss = new WebSocketServer({ port: 8765 });
351 |     const proxyConnected = new Promise<void>((resolve, reject) => {
352 |       wss.once('connection', () => {
353 |         resolve();
354 |       });
355 |     });
356 |     const mp = new MITMProxy(cb, onlyInterceptTextFiles);
357 |     // Set up WSS callbacks before MITMProxy connects.
358 |     mp._initializeWSS(wss);
359 |     await new Promise<void>((resolve, reject) => {
360 |       wss.once('listening', () => {
361 |         wss.removeListener('error', reject);
362 |         resolve();
363 |       });
364 |       wss.once('error', reject);
365 |     });
366 | 
367 |     try {
368 |       try {
369 |         await waitForPort(8080, 1);
370 |         if (!quiet) {
371 |           console.log(`MITMProxy already running.`);
372 |         }
373 |       } catch (e) {
374 |         if (!quiet) {
375 |           console.log(`MITMProxy not running; starting up mitmproxy.`);
376 |         }
377 |         // Start up MITM process.
378 |         // --anticache means to disable caching, which gets in the way of transparently rewriting content.
379 |         const scriptArgs = interceptPaths.length > 0 ? ["--set", `intercept=${interceptPaths.join(",")}`] : [];
380 |         scriptArgs.push("--set", `onlyInterceptTextFiles=${onlyInterceptTextFiles}`);
381 |         if (ignoreHosts) {
382 |           scriptArgs.push(`--ignore-hosts`, ignoreHosts);
383 |         }
384 | 
385 |         const options = ["--anticache", "-s", resolve(__dirname, `../scripts/proxy.py`)].concat(scriptArgs);
386 |         if (quiet) {
387 |           options.push('-q');
388 |         }
389 |         
390 |         // allow self-signed SSL certificates
391 |         options.push("--ssl-insecure");
392 |         
393 |         const mitmProcess = spawn("mitmdump", options, {
394 |           stdio: 'inherit'
395 |         });
396 |         const mitmProxyExited = new Promise<void>((_, reject) => {
397 |           mitmProcess.once('error', reject);
398 |           mitmProcess.once('exit', reject);
399 |         });
400 |         if (MITMProxy._activeProcesses.push(mitmProcess) === 1) {
401 |           process.on('SIGINT', MITMProxy._cleanup);
402 |           process.on('exit', MITMProxy._cleanup);
403 |         }
404 |         mp._initializeMITMProxy(mitmProcess);
405 |         // Wait for port 8080 to come online.
406 |         const waitingForPort = waitForPort(8080);
407 |         try {
408 |           // Fails if mitmproxy exits before port becomes available.
409 |           await Promise.race([mitmProxyExited, waitingForPort]);
410 |         } catch (e) {
411 |           if (e && typeof(e) === 'object' && e.code === "ENOENT") {
412 |             throw new Error(`mitmdump, which is an executable that ships with mitmproxy, is not on your PATH. Please ensure that you can run mitmdump --version successfully from your command line.`)
413 |           } else {
414 |             throw new Error(`Unable to start mitmproxy: ${e}`);
415 |           }
416 |         }
417 |       }
418 |       await proxyConnected;
419 |     } catch (e) {
420 |       await new Promise<any>((resolve) => wss.close(resolve));
421 |       throw e;
422 |     }
423 | 
424 |     return mp;
425 |   }
426 | 
427 |   private static _cleanupCalled = false;
428 |   private static _cleanup(): void {
429 |     if (MITMProxy._cleanupCalled) {
430 |       return;
431 |     }
432 |     MITMProxy._cleanupCalled = true;
433 |     MITMProxy._activeProcesses.forEach((p) => {
434 |       p.kill('SIGKILL');
435 |     });
436 |   }
437 | 
438 |   private _stashEnabled: boolean = false;
439 |   // Toggle whether or not mitmproxy-node stashes modified server responses.
440 |   // **Not used for performance**, but enables Node.js code to fetch previous server responses from the proxy.
441 |   public get stashEnabled(): boolean {
442 |     return this._stashEnabled;
443 |   }
444 |   public set stashEnabled(v: boolean) {
445 |     if (!v) {
446 |       this._stash.clear();
447 |     }
448 |     this._stashEnabled = v;
449 |   }
450 |   private _mitmProcess: ChildProcess = null;
451 |   private _mitmError: Error = null;
452 |   private _wss: WebSocketServer = null;
453 |   public cb: Interceptor;
454 |   public readonly onlyInterceptTextFiles: boolean;
455 |   private _stash = new Map<string, StashedItem>();
456 |   private _stashFilter: (url: string, item: StashedItem) => boolean = defaultStashFilter;
457 |   public get stashFilter(): (url: string, item: StashedItem) => boolean {
458 |     return this._stashFilter;
459 |   }
460 |   public set stashFilter(value: (url: string, item: StashedItem) => boolean) {
461 |     if (typeof(value) === 'function') {
462 |       this._stashFilter = value;
463 |     } else if (value === null) {
464 |       this._stashFilter = defaultStashFilter;
465 |     } else {
466 |       throw new Error(`Invalid stash filter: Expected a function.`);
467 |     }
468 |   }
469 | 
470 |   private constructor(cb: Interceptor, onlyInterceptTextFiles: boolean) {
471 |     this.cb = cb;
472 |     this.onlyInterceptTextFiles = onlyInterceptTextFiles;
473 |   }
474 | 
475 |   private _initializeWSS(wss: WebSocketServer): void {
476 |     this._wss = wss;
477 |     this._wss.on('connection', (ws) => {
478 |       ws.on('error', (e) => {
479 |         if ((e as any).code !== "ECONNRESET") {
480 |           console.log(`WebSocket error: ${e}`);
481 |         }
482 |       });
483 |       ws.on('message', async (message: Buffer) => {
484 |         const original = InterceptedHTTPMessage.FromBuffer(message);
485 |         const rv = this.cb(original);
486 |         if (rv && typeof(rv) === 'object' && rv.then) {
487 |           await rv;
488 |         }
489 |         // Remove transfer-encoding. We don't support chunked.
490 |         if (this._stashEnabled) {
491 |           const item = new StashedItem(original.request.rawUrl, original.response.getHeader('content-type'), original.responseBody);
492 |           if (this._stashFilter(original.request.rawUrl, item)) {
493 |             this._stash.set(original.request.rawUrl, item);
494 |           }
495 |         }
496 |         ws.send(original.toBuffer());
497 |       });
498 |     });
499 |   }
500 | 
501 |   private _initializeMITMProxy(mitmProxy: ChildProcess): void {
502 |     this._mitmProcess = mitmProxy;
503 |     this._mitmProcess.on('exit', (code, signal) => {
504 |       const index = MITMProxy._activeProcesses.indexOf(this._mitmProcess);
505 |       if (index !== -1) {
506 |         MITMProxy._activeProcesses.splice(index, 1);
507 |       }
508 |       if (code !== null) {
509 |         if (code !== 0) {
510 |           this._mitmError = new Error(`Process exited with code ${code}.`);
511 |         }
512 |       } else {
513 |         this._mitmError = new Error(`Process exited due to signal ${signal}.`);
514 |       }
515 |     });
516 |     this._mitmProcess.on('error', (err) => {
517 |       this._mitmError = err;
518 |     });
519 |   }
520 | 
521 |   /**
522 |    * Retrieves the given URL from the stash.
523 |    * @param url
524 |    */
525 |   public getFromStash(url: string): StashedItem {
526 |     return this._stash.get(url);
527 |   }
528 | 
529 |   public forEachStashItem(cb: (value: StashedItem, url: string) => void): void {
530 |     this._stash.forEach(cb);
531 |   }
532 | 
533 |   /**
534 |    * Requests the given URL from the proxy.
535 |    */
536 |   public async proxyGet(urlString: string): Promise<HTTPResponse> {
537 |     const url = parseURL(urlString);
538 |     const get = url.protocol === "http:" ? httpGet : httpsGet;
539 |     return new Promise<HTTPResponse>((resolve, reject) => {
540 |       const req = get({
541 |         url: urlString,
542 |         headers: {
543 |           host: url.host
544 |         },
545 |         host: 'localhost',
546 |         port: 8080,
547 |         path: urlString
548 |       }, (res) => {
549 |         const data = new Array<Buffer>();
550 |         res.on('data', (chunk: Buffer) => {
551 |           data.push(chunk);
552 |         });
553 |         res.on('end', () => {
554 |           const d = Buffer.concat(data);
555 |           resolve({
556 |             statusCode: res.statusCode,
557 |             headers: res.headers,
558 |             body: d
559 |           } as HTTPResponse);
560 |         });
561 |         res.once('error', reject);
562 |       });
563 |       req.once('error', reject);
564 |     });
565 |   }
566 | 
567 |   public async shutdown(): Promise<void> {
568 |     return new Promise<void>((resolve, reject) => {
569 |       const closeWSS = () => {
570 |         this._wss.close((err) => {
571 |           if (err) {
572 |             reject(err);
573 |           } else {
574 |             resolve();
575 |           }
576 |         });
577 |       };
578 | 
579 |       if (this._mitmProcess && !this._mitmProcess.killed) {
580 |         this._mitmProcess.once('exit', (code, signal) => {
581 |           closeWSS();
582 |         });
583 |         this._mitmProcess.kill('SIGTERM');
584 |       } else {
585 |         closeWSS();
586 |       }
587 |     });
588 |   }
589 | }
590 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "compilerOptions": {
 3 |         "module": "commonjs",
 4 |         "target": "es6",
 5 |         "noImplicitAny": true,
 6 |         "inlineSourceMap": true,
 7 |         "inlineSources": true,
 8 |         "noImplicitThis": true,
 9 |         "noUnusedLocals": true,
10 |         "noImplicitReturns": true,
11 |         "declaration": true,
12 |         "lib": [
13 |             "dom",
14 |             "es2015"
15 |         ],
16 |         "outDir": "dist"
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------