allproxy/build/server/src/HttpConnectHandler.js

AllProxy: MITM HTTP Debugging Tool.

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.HttpVersion = void 0;
const HttpOrHttpsServer_1 = __importDefault(require("./HttpOrHttpsServer"));
const Https2Server_1 = __importDefault(require("./Https2Server"));
const net_1 = __importDefault(require("net"));
const Global_1 = __importDefault(require("./Global"));
const ConsoleLog_1 = __importDefault(require("./ConsoleLog"));
const HttpOrHttpsServers = {};
const https2Servers = {};
var HttpVersion;
(function (HttpVersion) {
    // eslint-disable-next-line no-unused-vars
    HttpVersion[HttpVersion["HTTP1"] = 1] = "HTTP1";
    // eslint-disable-next-line no-unused-vars
    HttpVersion[HttpVersion["HTTP2"] = 2] = "HTTP2";
})(HttpVersion = exports.HttpVersion || (exports.HttpVersion = {}));
;
let httpVersion = HttpVersion.HTTP1;
class HttpConnectHandler {
    static start(_httpVersion) {
        return __awaiter(this, void 0, void 0, function* () {
            httpVersion = _httpVersion;
        });
    }
    static doConnect(httpXSocket, data) {
        return __awaiter(this, void 0, void 0, function* () {
            ConsoleLog_1.default.debug('HttpConnectHandler doConnect', data.toString());
            const hostPort = data.toString().split(' ', 2)[1];
            const tokens = hostPort.split(':', 2);
            const port = tokens.length === 2 ? parseInt(tokens[1]) : 443;
            HttpConnectHandler.onConnect(tokens[0], port, httpXSocket);
        });
    }
    static onConnect(hostname, port, socket) {
        return __awaiter(this, void 0, void 0, function* () {
            ConsoleLog_1.default.debug('HttpConnectHandler onConnect', hostname, port);
            const proxyConfig = Global_1.default.socketIoManager.findGrpcProxyConfig(hostname, port);
            if (proxyConfig) {
                ConsoleLog_1.default.info(`Proxy ${hostname}:${port} to gRPC`);
                HttpConnectHandler.createTunnel(socket, parseInt(proxyConfig.path), 'localhost');
            }
            else {
                const key = hostname;
                let httpsServer = httpVersion === HttpVersion.HTTP1 ? HttpOrHttpsServers[key] : https2Servers[key];
                if (!httpsServer) {
                    if (httpVersion === HttpVersion.HTTP1) {
                        httpsServer = new HttpOrHttpsServer_1.default('forward', 'https:', hostname, port);
                        HttpOrHttpsServers[key] = httpsServer;
                    }
                    else {
                        httpsServer = new Https2Server_1.default(hostname, port, 'forward');
                        https2Servers[key] = httpsServer;
                    }
                    ConsoleLog_1.default.debug('HttpConnectHandler start https server');
                    yield httpsServer.start(0);
                }
                else {
                    ConsoleLog_1.default.debug('HttpConnectHandler wait for https server to start');
                    yield httpsServer.waitForServerToStart();
                }
                // Create tunnel from client to Http2HttpsServer
                HttpConnectHandler.createTunnel(socket, httpsServer.getEphemeralPort(), 'localhost');
            }
        });
    }
    static respond(socket) {
        ConsoleLog_1.default.debug('HttpConnectHandler HTTP/1.1 200 Connection Established');
        socket.write('HTTP/1.1 200 Connection Established\r\n' +
            // 'Connection: Keep-Alive\n\r' +
            'Proxy-agent: Node.js-Proxy\r\n' +
            '\r\n');
    }
    // Create tunnel from client to AllProxy https server.  The AllProxy https server decrypts and captures
    // the HTTP messages, and forwards it to the origin server.
    static createTunnel(httpXSocket, httpsServerPort, hostname) {
        ConsoleLog_1.default.debug('HttpConnectionHandler createTunnel', httpsServerPort, hostname);
        const httpsServerSocket = net_1.default.connect(httpsServerPort, hostname, () => {
            HttpConnectHandler.respond(httpXSocket);
            // Tunnel data between client and server
            httpsServerSocket.pipe(httpXSocket);
            httpXSocket.pipe(httpsServerSocket);
        });
        httpXSocket.on('error', (err) => {
            ConsoleLog_1.default.debug('HttpConnectHandler Client socket error: ', err);
        });
        httpsServerSocket.on('error', (err) => {
            ConsoleLog_1.default.debug('HttpConnectHandler Server socket error: ', err);
        });
    }
}
exports.default = HttpConnectHandler;
//# sourceMappingURL=HttpConnectHandler.js.map