allproxy/build/server/src/Resend.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 });
const url_1 = __importDefault(require("url"));
const HttpMessage_1 = __importDefault(require("./HttpMessage"));
const ProxyConfig_1 = __importDefault(require("../../common/ProxyConfig"));
const Global_1 = __importDefault(require("./Global"));
const ConsoleLog_1 = __importDefault(require("./ConsoleLog"));
const fetch = require('node-fetch');
const resend = (forwardProxy, method, url, message, body) => __awaiter(void 0, void 0, void 0, function* () {
    const headers = {};
    const unsafeHeaders = [
        'host',
        'connection',
        'content-length',
        'origin',
        'referer',
        'accept-encoding',
        'cookie',
        'sec-fetch-dest',
        'proxy-connection'
    ];
    for (const header in message.requestHeaders) {
        if (unsafeHeaders.indexOf(header) === -1) {
            headers[header] = message.requestHeaders[header];
        }
    }
    headers.allproxy = 'resend';
    // Header environment variable replacement:
    for (const key in headers) {
        const value = headers[key];
        if (value.indexOf('$') !== -1 && value.length > 1) {
            const s = value.indexOf('$');
            let e = value.substring(s).indexOf(' ');
            if (e === -1) {
                e = undefined;
            }
            const replaceVar = value.substring(s, e);
            let value2 = process.env[replaceVar.substring(1)];
            if (value2 && value2.length > 0) {
                value2 = value.replace(replaceVar, value2);
                ConsoleLog_1.default.info(`Environment variable "${value}" is defined: Setting header "${key}" to "${value2}"`);
                headers[key] = value2;
            }
        }
    }
    // eslint-disable-next-line node/no-deprecated-api
    const reqUrl = url_1.default.parse(url);
    // URL environment variable replacement:
    if (url.indexOf('$')) {
        const path = reqUrl.pathname;
        if (path) {
            const tokens = path.split('/');
            for (let i = 0; i < tokens.length; ++i) {
                if (tokens[i].startsWith('$') && tokens[i].length > 1) {
                    const value = process.env[tokens[i].substring(1)];
                    if (value && value.length > 0) {
                        ConsoleLog_1.default.info(`Environment variable "${tokens[i]}" is defined: Replaced with "${value}"`);
                        url = url.replace('/' + tokens[i], '/' + value);
                    }
                }
            }
        }
    }
    // ConsoleLog.info(`Resend ${method} ${url} \n${body} \n${headers}`)
    body = typeof body === 'string' && body.length === 0 ? undefined : body;
    let httpMessage;
    let clientHostName;
    if (forwardProxy) {
        clientHostName = yield Global_1.default.resolveIp(reqUrl.hostname);
        httpMessage = recordHttpRequest();
    }
    if (body && body != null && typeof body === 'object') {
        body = JSON.stringify(body);
    }
    try {
        ConsoleLog_1.default.debug('resend', method, url, headers, body);
        const response = yield fetch(url, {
            method: method.toLowerCase(),
            headers,
            body: body === null ? undefined : body
        });
        try {
            const data = yield response.json();
            recordHttpResponse(response, data);
        }
        catch (e) {
            try {
                recordHttpResponse(response, "");
            }
            catch (e) {
                httpMessage.emitMessageToBrowser(body, 520, {}, typeof e === 'string' ? { error: e } : e);
            }
        }
    }
    catch (e) {
        httpMessage.emitMessageToBrowser(body, 520, {}, typeof e === 'string' ? { error: e } : e);
    }
    function recordHttpRequest() {
        const proxyType = reqUrl.protocol ? 'forward' : 'reverse';
        let proxyConfig = Global_1.default.socketIoManager.findProxyConfigMatchingURL('https:', clientHostName, reqUrl, proxyType);
        // Always proxy forward proxy requests
        if (proxyConfig === undefined) {
            proxyConfig = new ProxyConfig_1.default();
            proxyConfig.path = reqUrl.pathname;
            proxyConfig.protocol = reqUrl.protocol;
            proxyConfig.hostname = reqUrl.hostname;
            proxyConfig.port = reqUrl.port === null
                ? reqUrl.protocol === 'http:' ? 80 : 443
                : +reqUrl.port;
        }
        const sequenceNumber = Global_1.default.nextSequenceNumber();
        const httpMessage = new HttpMessage_1.default(reqUrl.protocol, proxyConfig, sequenceNumber, clientHostName, method, url, headers);
        httpMessage.emitMessageToBrowser(body);
        return httpMessage;
    }
    function recordHttpResponse(response, data) {
        httpMessage.emitMessageToBrowser(body, response.status, response.headers, data);
    }
});
exports.default = resend;
//# sourceMappingURL=Resend.js.map