@requestly/requestly-proxy 1.0.0

package/dist/components/proxy-middleware/rule_action_processor/processors/modify_response_processor.js

@@ -0,0 +1,109 @@
+"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 proxy_1 = require("../../../../lib/proxy");
+const requestly_core_1 = require("@requestly/requestly-core");
+const proxy_ctx_helper_1 = require("../../helpers/proxy_ctx_helper");
+const utils_1 = require("../utils");
+const fs_1 = __importDefault(require("fs"));
+const { types } = require("util");
+const process_modify_response_action = (action, ctx) => {
+    const allowed_handlers = [proxy_1.PROXY_HANDLER_TYPE.ON_RESPONSE_END];
+    if (!allowed_handlers.includes(ctx.currentHandler)) {
+        return (0, utils_1.build_action_processor_response)(action, false);
+    }
+    if (action.responseType &&
+        action.responseType === requestly_core_1.CONSTANTS.RESPONSE_BODY_TYPES.CODE) {
+        modify_response_using_code(action, ctx);
+        return (0, utils_1.build_action_processor_response)(action, true);
+    }
+    else if (action.responseType === requestly_core_1.CONSTANTS.RESPONSE_BODY_TYPES.LOCAL_FILE) {
+        modify_response_using_local(action, ctx);
+        return (0, utils_1.build_action_processor_response)(action, true);
+    }
+    else {
+        modify_response(ctx, action.response, action.statusCode);
+        return (0, utils_1.build_action_processor_response)(action, true);
+    }
+};
+const modify_response = (ctx, new_resp, status_code) => {
+    ctx.rq_response_body = new_resp;
+    ctx.rq_response_status_code = status_code;
+};
+const modify_response_using_local = (action, ctx) => {
+    let data;
+    try {
+        data = fs_1.default.readFileSync(action.response, "utf-8");
+        modify_response(ctx, data, action.statusCode);
+    }
+    catch (err) {
+        console.log("Some Error while reading file");
+    }
+};
+const modify_response_using_code = (action, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    let userFunction = null;
+    try {
+        userFunction = requestly_core_1.UTILS.GET_FUNCTION_FROM_STRING(action.response);
+    }
+    catch (error) {
+        // User has provided an invalid function
+        return modify_response(ctx, "Can't parse Requestly function. Please recheck. Error Code 7201. Actual Error: " +
+            error.message);
+    }
+    if (!userFunction || typeof userFunction !== "function") {
+        // User has provided an invalid function
+        return modify_response(ctx, "Can't parse Requestly function. Please recheck. Error Code 944.");
+    }
+    // Everything good so far. Now try to execute user's function
+    let finalResponse = null;
+    try {
+        const args = {
+            method: ctx.clientToProxyRequest
+                ? ctx.clientToProxyRequest.method
+                    ? ctx.clientToProxyRequest.method
+                    : null
+                : null,
+            response: ctx.rq_response_body,
+            url: (0, proxy_ctx_helper_1.get_request_url)(ctx),
+            responseType: ctx.serverToProxyResponse.headers["content-type"],
+            requestHeaders: ctx.clientToProxyRequest.headers,
+            requestData: null,
+        };
+        try {
+            args.responseJSON = JSON.parse(args.response);
+        }
+        catch (_a) {
+            /*Do nothing -- could not parse body as JSON */
+        }
+        finalResponse = userFunction(args);
+        if (types.isPromise(finalResponse)) {
+            finalResponse = yield finalResponse;
+        }
+        const isResponseJSON = args.responseType && args.responseType.includes("application/json");
+        if (typeof finalResponse === "object" && isResponseJSON) {
+            finalResponse = JSON.stringify(finalResponse);
+        }
+        if (finalResponse && typeof finalResponse === "string") {
+            return modify_response(ctx, finalResponse, action.statusCode);
+        }
+        else
+            throw new Error("Returned value is not a string");
+    }
+    catch (error) {
+        // Function parsed but failed to execute
+        return modify_response(ctx, "Can't execute Requestly function. Please recheck. Error Code 187. Actual Error: " +
+            error.message);
+    }
+});
+exports.default = process_modify_response_action;

package/dist/components/proxy-middleware/rule_action_processor/processors/modify_user_agent_processor.d.ts

@@ -0,0 +1,6 @@
+export default process_modify_user_agent_action;
+declare function process_modify_user_agent_action(action: any, ctx: any): {
+    action: any;
+    success: boolean;
+    post_process_data: any;
+};

package/dist/components/proxy-middleware/rule_action_processor/processors/modify_user_agent_processor.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const proxy_1 = require("../../../../lib/proxy");
+const utils_1 = require("../utils");
+const process_modify_user_agent_action = (action, ctx) => {
+    const allowed_handlers = [proxy_1.PROXY_HANDLER_TYPE.ON_REQUEST];
+    if (!allowed_handlers.includes(ctx.currentHandler)) {
+        return (0, utils_1.build_action_processor_response)(action, false);
+    }
+    if (ctx.currentHandler == proxy_1.PROXY_HANDLER_TYPE.ON_REQUEST) {
+        modify_request_headers(action, ctx);
+        return (0, utils_1.build_action_processor_response)(action, true);
+    }
+};
+const modify_request_headers = (action, ctx) => {
+    const newRequestHeaders = action.newRequestHeaders;
+    for (var headerName in ctx.proxyToServerRequestOptions.headers) {
+        if (ctx.proxyToServerRequestOptions.headers.hasOwnProperty(headerName)) {
+            delete ctx.proxyToServerRequestOptions.headers[headerName];
+        }
+    }
+    // Set Request Headers
+    newRequestHeaders.forEach((pair) => (ctx.proxyToServerRequestOptions.headers[pair.name] = pair.value));
+};
+exports.default = process_modify_user_agent_action;

package/dist/components/proxy-middleware/rule_action_processor/processors/redirect_processor.d.ts

@@ -0,0 +1,6 @@
+export default process_redirect_action;
+declare function process_redirect_action(action: any, ctx: any): Promise<true | {
+    action: any;
+    success: boolean;
+    post_process_data: any;
+}>;

package/dist/components/proxy-middleware/rule_action_processor/processors/redirect_processor.js

@@ -0,0 +1,58 @@
+"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 proxy_1 = require("../../../../lib/proxy");
+const proxy_ctx_helper_1 = require("../../helpers/proxy_ctx_helper");
+const modified_requests_pool_1 = __importDefault(require("../modified_requests_pool"));
+const handle_mixed_response_1 = __importDefault(require("../handle_mixed_response"));
+const utils_1 = require("../utils");
+const { URL } = require("url");
+// adding util to get origin header for handling cors
+const getRequestOrigin = (ctx) => {
+    const originalRequestHeaders = ctx.rq.original_request.headers || {};
+    return (originalRequestHeaders["Origin"] ||
+        originalRequestHeaders["origin"] ||
+        originalRequestHeaders["ORIGIN"]);
+};
+const process_redirect_action = (action, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const allowed_handlers = [proxy_1.PROXY_HANDLER_TYPE.ON_REQUEST];
+    if (!allowed_handlers.includes(ctx.currentHandler)) {
+        return (0, utils_1.build_action_processor_response)(action, false);
+    }
+    const current_url = (0, proxy_ctx_helper_1.get_request_url)(ctx);
+    const new_url = action.url;
+    const request_url = current_url.replace(/www\./g, "");
+    // Skip if already redirected
+    if (modified_requests_pool_1.default.isURLModified(request_url)) {
+        // Do nothing
+        return (0, utils_1.build_action_processor_response)(action, false);
+    }
+    else {
+        modified_requests_pool_1.default.add(new_url);
+    }
+    const { status: isMixedResponse, response_data } = yield (0, handle_mixed_response_1.default)(ctx, new_url);
+    if (isMixedResponse) {
+        return (0, utils_1.build_action_processor_response)(action, true, (0, utils_1.build_post_process_data)(response_data.status_code, response_data.headers, response_data.body));
+    }
+    // If this is a pre-flight request, don't redirect it
+    if ((0, proxy_ctx_helper_1.is_request_preflight)(ctx))
+        return true;
+    return (0, utils_1.build_action_processor_response)(action, true, (0, utils_1.build_post_process_data)(307, {
+        "Cache-Control": "no-cache",
+        "Access-Control-Allow-Origin": getRequestOrigin(ctx) || "*",
+        "Access-Control-Allow-Credentials": "true",
+        Location: new_url,
+    }, null));
+});
+exports.default = process_redirect_action;

package/dist/components/proxy-middleware/rule_action_processor/utils.d.ts

@@ -0,0 +1,11 @@
+export function build_action_processor_response(action: any, success?: boolean, post_process_data?: any): {
+    action: any;
+    success: boolean;
+    post_process_data: any;
+};
+export function build_post_process_data(status_code: any, headers: any, body: any): {
+    status_code: any;
+    headers: any;
+    body: any;
+};
+export function get_success_actions_from_action_results(action_result_objs?: any[]): any[];

package/dist/components/proxy-middleware/rule_action_processor/utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_success_actions_from_action_results = exports.build_post_process_data = exports.build_action_processor_response = void 0;
+const build_action_processor_response = (action, success = false, post_process_data = null) => {
+    let resp = {
+        action: action,
+        success: success,
+        post_process_data: post_process_data,
+    };
+    return resp;
+};
+exports.build_action_processor_response = build_action_processor_response;
+const build_post_process_data = (status_code, headers, body) => {
+    if (!status_code && !headers && !body) {
+        return null;
+    }
+    let data = {
+        status_code,
+        headers,
+        body,
+    };
+    return data;
+};
+exports.build_post_process_data = build_post_process_data;
+const get_success_actions_from_action_results = (action_result_objs = []) => {
+    if (!action_result_objs) {
+        return [];
+    }
+    // BY default success is false
+    const success_action_results_objs = action_result_objs.filter((obj) => obj && obj && obj.success === true);
+    return success_action_results_objs.map((obj) => obj.action);
+};
+exports.get_success_actions_from_action_results = get_success_actions_from_action_results;

package/dist/components/ssl-proxying/ssl-proxying-manager.d.ts

@@ -0,0 +1,3 @@
+declare class SSLProxyingManager {
+}
+export default SSLProxyingManager;

package/dist/components/ssl-proxying/ssl-proxying-manager.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// TODO: @sahil to add this
+class SSLProxyingManager {
+}
+exports.default = SSLProxyingManager;

package/dist/constants/cert.d.ts

@@ -0,0 +1,7 @@
+export declare const certConfig: {
+    CERT_NAME: string;
+    CERT_VALIDITY: {
+        START_BEFORE: number;
+        END_AFTER: number;
+    };
+};

package/dist/constants/cert.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.certConfig = void 0;
+exports.certConfig = {
+    CERT_NAME: "RQProxyCA",
+    CERT_VALIDITY: {
+        // Number of days - before the current date - Keep minimum 1 to avoid 12am date change issues
+        START_BEFORE: 1,
+        // Number of days - after the current date - Keep minimum 1 to avoid 12am date change issues
+        // CAUTION : Increasing this count might affect current app users
+        END_AFTER: 365,
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import RQProxy from "./rq-proxy";
+import RQProxyProvider from "./rq-proxy-provider";
+export { RQProxy, RQProxyProvider, };
+export default RQProxy;

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RQProxyProvider = exports.RQProxy = void 0;
+const rq_proxy_1 = __importDefault(require("./rq-proxy"));
+exports.RQProxy = rq_proxy_1.default;
+const rq_proxy_provider_1 = __importDefault(require("./rq-proxy-provider"));
+exports.RQProxyProvider = rq_proxy_provider_1.default;
+exports.default = rq_proxy_1.default;

package/dist/lib/proxy/bin/mitm-proxy.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/lib/proxy/bin/mitm-proxy.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+"use strict";
+var yargs = require("yargs");
+var debug = require("debug")("http-mitm-proxy:bin");
+var args = yargs
+    .alias("h", "help")
+    .alias("h", "?")
+    .options("port", {
+    default: 80,
+    describe: "HTTP Port.",
+})
+    .alias("p", "port")
+    .options("host", {
+    describe: "HTTP Listen Interface.",
+}).argv;
+if (args.help) {
+    yargs.showHelp();
+    process.exit(-1);
+}
+var proxy = require("../lib/proxy")();
+proxy.onError(function (ctx, err, errorKind) {
+    debug(errorKind, err);
+});
+proxy.listen(args, function (err) {
+    if (err) {
+        debug("Failed to start listening on port " + args.port, err);
+        return process.exit(1);
+    }
+    debug("proxy listening on " + args.port);
+});

package/dist/lib/proxy/custom/utils/checkInvalidHeaderChar.d.ts

@@ -0,0 +1,8 @@
+export = checkInvalidHeaderChar;
+/**
+ * True if val contains an invalid field-vchar
+ *  field-value    = *( field-content / obs-fold )
+ *  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+ *  field-vchar    = VCHAR / obs-text
+ */
+declare function checkInvalidHeaderChar(val: any): boolean;

package/dist/lib/proxy/custom/utils/checkInvalidHeaderChar.js

@@ -0,0 +1,14 @@
+/**
+ * @sagar - Polyfill for _http_common.js
+ */
+const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
+/**
+ * True if val contains an invalid field-vchar
+ *  field-value    = *( field-content / obs-fold )
+ *  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+ *  field-vchar    = VCHAR / obs-text
+ */
+function checkInvalidHeaderChar(val) {
+    return headerCharRegex.test(val);
+}
+module.exports = checkInvalidHeaderChar;

package/dist/lib/proxy/index.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

package/dist/lib/proxy/index.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./lib/proxy");

package/dist/lib/proxy/lib/ca.d.ts

@@ -0,0 +1,8 @@
+export = CA;
+declare class CA {
+    randomSerialNumber(): string;
+    generateCA(callback: any): void;
+    loadCA(callback: any): void;
+    generateServerCertificateKeys(hosts: any, cb: any): void;
+    getCACertPath(): string;
+}

package/dist/lib/proxy/lib/ca.js

@@ -0,0 +1,277 @@
+"use strict";
+// Sentry
+var Sentry = require("@sentry/browser");
+// Config
+const staticConfig = require("../../../constants/cert").certConfig;
+var FS = require("fs");
+var path = require("path");
+var Forge = require("node-forge");
+var pki = Forge.pki;
+var mkdirp = require("mkdirp");
+var async = require("async");
+var CAattrs = [
+    {
+        name: "commonName",
+        value: staticConfig.CERT_NAME,
+    },
+    {
+        name: "countryName",
+        value: "Internet",
+    },
+    {
+        shortName: "ST",
+        value: "Internet",
+    },
+    {
+        name: "localityName",
+        value: "Internet",
+    },
+    {
+        name: "organizationName",
+        value: staticConfig.CERT_NAME,
+    },
+    {
+        shortName: "OU",
+        value: "CA",
+    },
+];
+var CAextensions = [
+    {
+        name: "basicConstraints",
+        cA: true,
+    },
+    {
+        name: "keyUsage",
+        keyCertSign: true,
+        digitalSignature: true,
+        nonRepudiation: true,
+        keyEncipherment: true,
+        dataEncipherment: true,
+    },
+    {
+        name: "extKeyUsage",
+        serverAuth: true,
+        clientAuth: true,
+        codeSigning: true,
+        emailProtection: true,
+        timeStamping: true,
+    },
+    {
+        name: "nsCertType",
+        client: true,
+        server: true,
+        email: true,
+        objsign: true,
+        sslCA: true,
+        emailCA: true,
+        objCA: true,
+    },
+    {
+        name: "subjectKeyIdentifier",
+    },
+];
+var ServerAttrs = [
+    {
+        name: "countryName",
+        value: "Internet",
+    },
+    {
+        shortName: "ST",
+        value: "Internet",
+    },
+    {
+        name: "localityName",
+        value: "Internet",
+    },
+    {
+        name: "organizationName",
+        value: staticConfig.CERT_NAME,
+    },
+    {
+        shortName: "OU",
+        value: staticConfig.CERT_NAME,
+    },
+];
+var ServerExtensions = [
+    {
+        name: "basicConstraints",
+        cA: false,
+    },
+    {
+        name: "keyUsage",
+        keyCertSign: false,
+        digitalSignature: true,
+        nonRepudiation: false,
+        keyEncipherment: true,
+        dataEncipherment: true,
+    },
+    {
+        name: "extKeyUsage",
+        serverAuth: true,
+        clientAuth: true,
+        codeSigning: false,
+        emailProtection: false,
+        timeStamping: false,
+    },
+    {
+        name: "nsCertType",
+        client: true,
+        server: true,
+        email: false,
+        objsign: false,
+        sslCA: false,
+        emailCA: false,
+        objCA: false,
+    },
+    {
+        name: "subjectKeyIdentifier",
+    },
+];
+var CA = function () { };
+CA.create = function (caFolder, callback) {
+    var ca = new CA();
+    ca.baseCAFolder = caFolder;
+    ca.certsFolder = path.join(ca.baseCAFolder, "certs");
+    ca.keysFolder = path.join(ca.baseCAFolder, "keys");
+    async.series([
+        mkdirp.bind(null, ca.baseCAFolder),
+        mkdirp.bind(null, ca.certsFolder),
+        mkdirp.bind(null, ca.keysFolder),
+        function (callback) {
+            FS.exists(path.join(ca.certsFolder, "ca.pem"), function (exists) {
+                if (exists) {
+                    ca.loadCA(callback);
+                }
+                else {
+                    ca.generateCA(callback);
+                }
+            });
+        },
+    ], function (err) {
+        if (err) {
+            return callback(err);
+        }
+        return callback(null, ca);
+    });
+};
+CA.prototype.randomSerialNumber = function () {
+    // generate random 16 bytes hex string
+    var sn = "";
+    for (var i = 0; i < 4; i++) {
+        sn += ("00000000" + Math.floor(Math.random() * Math.pow(256, 4)).toString(16)).slice(-8);
+    }
+    return sn;
+};
+CA.prototype.generateCA = function (callback) {
+    var self = this;
+    pki.rsa.generateKeyPair({ bits: 2048 }, function (err, keys) {
+        if (err) {
+            return callback(err);
+        }
+        var cert = pki.createCertificate();
+        cert.publicKey = keys.publicKey;
+        cert.serialNumber = self.randomSerialNumber();
+        cert.validity.notBefore = new Date();
+        cert.validity.notBefore.setDate(cert.validity.notBefore.getDate() -
+            staticConfig.CERT_VALIDITY.START_BEFORE);
+        cert.validity.notAfter = new Date();
+        cert.validity.notAfter.setDate(cert.validity.notBefore.getDate() + staticConfig.CERT_VALIDITY.END_AFTER);
+        cert.setSubject(CAattrs);
+        cert.setIssuer(CAattrs);
+        cert.setExtensions(CAextensions);
+        cert.sign(keys.privateKey, Forge.md.sha256.create());
+        self.CAcert = cert;
+        self.CAkeys = keys;
+        async.parallel([
+            FS.writeFile.bind(null, path.join(self.certsFolder, "ca.pem"), pki.certificateToPem(cert)),
+            FS.writeFile.bind(null, path.join(self.keysFolder, "ca.private.key"), pki.privateKeyToPem(keys.privateKey)),
+            FS.writeFile.bind(null, path.join(self.keysFolder, "ca.public.key"), pki.publicKeyToPem(keys.publicKey)),
+        ], callback);
+    });
+};
+CA.prototype.loadCA = function (callback) {
+    var self = this;
+    async.auto({
+        certPEM: function (callback) {
+            FS.readFile(path.join(self.certsFolder, "ca.pem"), "utf-8", callback);
+        },
+        keyPrivatePEM: function (callback) {
+            FS.readFile(path.join(self.keysFolder, "ca.private.key"), "utf-8", callback);
+        },
+        keyPublicPEM: function (callback) {
+            FS.readFile(path.join(self.keysFolder, "ca.public.key"), "utf-8", callback);
+        },
+    }, function (err, results) {
+        if (err) {
+            return callback(err);
+        }
+        try {
+            self.CAcert = pki.certificateFromPem(results.certPEM);
+            self.CAkeys = {
+                privateKey: pki.privateKeyFromPem(results.keyPrivatePEM),
+                publicKey: pki.publicKeyFromPem(results.keyPublicPEM),
+            };
+        }
+        catch (err) {
+            Sentry.captureException(err);
+            return callback(err);
+        }
+        return callback();
+    });
+};
+CA.prototype.generateServerCertificateKeys = function (hosts, cb) {
+    var self = this;
+    if (typeof hosts === "string")
+        hosts = [hosts];
+    var mainHost = hosts[0];
+    var keysServer = pki.rsa.generateKeyPair(2048);
+    var certServer = pki.createCertificate();
+    certServer.publicKey = keysServer.publicKey;
+    certServer.serialNumber = this.randomSerialNumber();
+    certServer.validity.notBefore = new Date();
+    certServer.validity.notBefore.setDate(certServer.validity.notBefore.getDate() -
+        staticConfig.CERT_VALIDITY.START_BEFORE);
+    certServer.validity.notAfter = new Date();
+    certServer.validity.notAfter.setDate(certServer.validity.notBefore.getDate() +
+        staticConfig.CERT_VALIDITY.END_AFTER);
+    var attrsServer = ServerAttrs.slice(0);
+    attrsServer.unshift({
+        name: "commonName",
+        value: mainHost,
+    });
+    certServer.setSubject(attrsServer);
+    certServer.setIssuer(this.CAcert.issuer.attributes);
+    certServer.setExtensions(ServerExtensions.concat([
+        {
+            name: "subjectAltName",
+            altNames: hosts.map(function (host) {
+                if (host.match(/^[\d\.]+$/)) {
+                    return { type: 7, ip: host };
+                }
+                return { type: 2, value: host };
+            }),
+        },
+    ]));
+    certServer.sign(this.CAkeys.privateKey, Forge.md.sha256.create());
+    var certPem = pki.certificateToPem(certServer);
+    var keyPrivatePem = pki.privateKeyToPem(keysServer.privateKey);
+    var keyPublicPem = pki.publicKeyToPem(keysServer.publicKey);
+    FS.writeFile(this.certsFolder + "/" + mainHost.replace(/\*/g, "_") + ".pem", certPem, function (error) {
+        if (error)
+            console.error("Failed to save certificate to disk in " + self.certsFolder, error);
+    });
+    FS.writeFile(this.keysFolder + "/" + mainHost.replace(/\*/g, "_") + ".key", keyPrivatePem, function (error) {
+        if (error)
+            console.error("Failed to save private key to disk in " + self.keysFolder, error);
+    });
+    FS.writeFile(this.keysFolder + "/" + mainHost.replace(/\*/g, "_") + ".public.key", keyPublicPem, function (error) {
+        if (error)
+            console.error("Failed to save public key to disk in " + self.keysFolder, error);
+    });
+    // returns synchronously even before files get written to disk
+    cb(certPem, keyPrivatePem);
+};
+CA.prototype.getCACertPath = function () {
+    return this.certsFolder + "/ca.pem";
+};
+module.exports = CA;

package/dist/lib/proxy/lib/middleware/gunzip.d.ts

@@ -0,0 +1,2 @@
+export function onResponse(ctx: any, callback: any): any;
+export function onRequest(ctx: any, callback: any): any;