@earendil-works/gondolin 0.0.1 → 0.1.1

package/dist/qemu-net.js

@@ -1,756 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QemuNetworkBackend = void 0;
-const events_1 = require("events");
-const net_1 = __importDefault(require("net"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const dgram_1 = __importDefault(require("dgram"));
-const tls_1 = __importDefault(require("tls"));
-const crypto_1 = __importDefault(require("crypto"));
-const stream_1 = require("stream");
-const child_process_1 = require("child_process");
-const network_stack_1 = require("./network-stack");
-const HOP_BY_HOP_HEADERS = new Set([
-    "connection",
-    "keep-alive",
-    "proxy-connection",
-    "transfer-encoding",
-    "te",
-    "trailer",
-    "upgrade",
-]);
-class GuestTlsStream extends stream_1.Duplex {
-    constructor(onEncryptedWrite) {
-        super();
-        this.onEncryptedWrite = onEncryptedWrite;
-    }
-    pushEncrypted(data) {
-        this.push(data);
-    }
-    _read() {
-        // data is pushed via pushEncrypted
-    }
-    _write(chunk, _encoding, callback) {
-        this.onEncryptedWrite(Buffer.from(chunk));
-        callback();
-    }
-}
-class QemuNetworkBackend extends events_1.EventEmitter {
-    constructor(options) {
-        super();
-        this.options = options;
-        this.server = null;
-        this.socket = null;
-        this.waitingDrain = false;
-        this.stack = null;
-        this.udpSessions = new Map();
-        this.tcpSessions = new Map();
-        this.caCertPath = null;
-        this.caKeyPath = null;
-        this.tlsContexts = new Map();
-        this.policy = null;
-        this.policy = options.policy ?? null;
-    }
-    start() {
-        if (this.server)
-            return;
-        if (!fs_1.default.existsSync(path_1.default.dirname(this.options.socketPath))) {
-            fs_1.default.mkdirSync(path_1.default.dirname(this.options.socketPath), { recursive: true });
-        }
-        fs_1.default.rmSync(this.options.socketPath, { force: true });
-        this.server = net_1.default.createServer((socket) => this.attachSocket(socket));
-        this.server.on("error", (err) => this.emit("error", err));
-        this.server.listen(this.options.socketPath);
-    }
-    stop() {
-        this.detachSocket();
-        if (this.server) {
-            this.server.close();
-            this.server = null;
-        }
-    }
-    setPolicy(policy) {
-        this.policy = policy;
-        this.emit("policy", policy);
-    }
-    getPolicy() {
-        return this.policy;
-    }
-    attachSocket(socket) {
-        if (this.socket)
-            this.socket.destroy();
-        this.socket = socket;
-        this.waitingDrain = false;
-        this.resetStack();
-        socket.on("data", (chunk) => {
-            this.stack?.writeToNetwork(chunk);
-            this.flush();
-        });
-        socket.on("drain", () => {
-            this.waitingDrain = false;
-            this.flush();
-        });
-        socket.on("error", (err) => {
-            this.emit("error", err);
-            this.detachSocket();
-        });
-        socket.on("close", () => {
-            this.detachSocket();
-        });
-    }
-    detachSocket() {
-        if (this.socket) {
-            this.socket.destroy();
-            this.socket = null;
-        }
-        this.waitingDrain = false;
-        this.cleanupSessions();
-        this.stack?.reset();
-    }
-    resetStack() {
-        this.cleanupSessions();
-        this.stack = new network_stack_1.NetworkStack({
-            gatewayIP: this.options.gatewayIP,
-            vmIP: this.options.vmIP,
-            gatewayMac: this.options.gatewayMac,
-            vmMac: this.options.vmMac,
-            callbacks: {
-                onUdpSend: (message) => this.handleUdpSend(message),
-                onTcpConnect: (message) => this.handleTcpConnect(message),
-                onTcpSend: (message) => this.handleTcpSend(message),
-                onTcpClose: (message) => this.handleTcpClose(message),
-                onTcpPause: (message) => this.handleTcpPause(message),
-                onTcpResume: (message) => this.handleTcpResume(message),
-            },
-            allowTcpFlow: (info) => {
-                if (info.protocol !== "http" && info.protocol !== "tls") {
-                    if (this.options.debug) {
-                        this.emit("log", `[net] tcp blocked ${info.srcIP}:${info.srcPort} -> ${info.dstIP}:${info.dstPort} (${info.protocol})`);
-                    }
-                    return false;
-                }
-                const session = this.tcpSessions.get(info.key);
-                if (session) {
-                    session.protocol = info.protocol;
-                    if (info.protocol === "http" || info.protocol === "tls") {
-                        session.http = session.http ?? {
-                            buffer: Buffer.alloc(0),
-                            processing: false,
-                            closed: false,
-                        };
-                    }
-                }
-                return true;
-            },
-        });
-        this.stack.on("network-activity", () => this.flush());
-        this.stack.on("error", (err) => this.emit("error", err));
-        if (this.options.debug) {
-            this.stack.on("dhcp", (state, ip) => {
-                this.emit("log", `[net] dhcp ${state} ${ip}`);
-            });
-        }
-    }
-    flush() {
-        if (!this.socket || this.waitingDrain || !this.stack)
-            return;
-        while (this.stack.hasPendingData()) {
-            const chunk = this.stack.readFromNetwork(64 * 1024);
-            if (!chunk || chunk.length === 0)
-                break;
-            if (this.options.debug) {
-                this.emit("log", `[net] tx ${chunk.length} bytes to qemu`);
-            }
-            const ok = this.socket.write(chunk);
-            if (!ok) {
-                this.waitingDrain = true;
-                return;
-            }
-        }
-    }
-    cleanupSessions() {
-        for (const session of this.udpSessions.values()) {
-            try {
-                session.socket.close();
-            }
-            catch {
-                // ignore
-            }
-        }
-        this.udpSessions.clear();
-        for (const session of this.tcpSessions.values()) {
-            try {
-                session.socket?.destroy();
-            }
-            catch {
-                // ignore
-            }
-        }
-        this.tcpSessions.clear();
-    }
-    handleUdpSend(message) {
-        if (message.dstPort !== 53) {
-            if (this.options.debug) {
-                this.emit("log", `[net] udp blocked ${message.srcIP}:${message.srcPort} -> ${message.dstIP}:${message.dstPort}`);
-            }
-            return;
-        }
-        let session = this.udpSessions.get(message.key);
-        if (!session) {
-            const socket = dgram_1.default.createSocket("udp4");
-            session = {
-                socket,
-                srcIP: message.srcIP,
-                srcPort: message.srcPort,
-                dstIP: message.dstIP,
-                dstPort: message.dstPort,
-            };
-            this.udpSessions.set(message.key, session);
-            socket.on("message", (data, rinfo) => {
-                if (this.options.debug) {
-                    this.emit("log", `[net] udp recv ${rinfo.address}:${rinfo.port} -> ${session.srcIP}:${session.srcPort} (${data.length} bytes)`);
-                }
-                this.stack?.handleUdpResponse({
-                    data: Buffer.from(data),
-                    srcIP: session.srcIP,
-                    srcPort: session.srcPort,
-                    dstIP: session.dstIP,
-                    dstPort: session.dstPort,
-                });
-                this.flush();
-            });
-            socket.on("error", (err) => {
-                this.emit("error", err);
-            });
-        }
-        if (this.options.debug) {
-            this.emit("log", `[net] udp send ${message.srcIP}:${message.srcPort} -> ${message.dstIP}:${message.dstPort} (${message.payload.length} bytes)`);
-        }
-        session.socket.send(message.payload, message.dstPort, message.dstIP);
-    }
-    handleTcpConnect(message) {
-        const connectIP = message.dstIP === (this.options.gatewayIP ?? "192.168.127.1") ? "127.0.0.1" : message.dstIP;
-        const session = {
-            socket: null,
-            srcIP: message.srcIP,
-            srcPort: message.srcPort,
-            dstIP: message.dstIP,
-            dstPort: message.dstPort,
-            connectIP,
-            flowControlPaused: false,
-            protocol: null,
-            connected: false,
-            pendingWrites: [],
-        };
-        this.tcpSessions.set(message.key, session);
-        this.stack?.handleTcpConnected({ key: message.key });
-        this.flush();
-    }
-    handleTcpSend(message) {
-        const session = this.tcpSessions.get(message.key);
-        if (!session)
-            return;
-        if (session.protocol === "http") {
-            this.handlePlainHttpData(message.key, session, message.data);
-            return;
-        }
-        if (session.protocol === "tls") {
-            this.handleTlsData(message.key, session, message.data);
-            return;
-        }
-        this.ensureTcpSocket(message.key, session);
-        if (session.socket && session.connected && session.socket.writable) {
-            session.socket.write(message.data);
-        }
-        else {
-            session.pendingWrites.push(message.data);
-        }
-    }
-    handleTcpClose(message) {
-        const session = this.tcpSessions.get(message.key);
-        if (session) {
-            session.http = undefined;
-            if (session.tls) {
-                if (message.destroy) {
-                    session.tls.socket.destroy();
-                }
-                else {
-                    session.tls.socket.end();
-                }
-                session.tls = undefined;
-            }
-            if (session.socket) {
-                if (message.destroy) {
-                    session.socket.destroy();
-                }
-                else {
-                    session.socket.end();
-                }
-            }
-            else {
-                this.tcpSessions.delete(message.key);
-            }
-        }
-    }
-    handleTcpPause(message) {
-        const session = this.tcpSessions.get(message.key);
-        if (session && session.socket) {
-            session.flowControlPaused = true;
-            session.socket.pause();
-        }
-    }
-    handleTcpResume(message) {
-        const session = this.tcpSessions.get(message.key);
-        if (session && session.socket) {
-            session.flowControlPaused = false;
-            session.socket.resume();
-        }
-    }
-    ensureTcpSocket(key, session) {
-        if (session.socket)
-            return;
-        const socket = new net_1.default.Socket();
-        session.socket = socket;
-        socket.connect(session.dstPort, session.connectIP, () => {
-            session.connected = true;
-            for (const pending of session.pendingWrites) {
-                socket.write(pending);
-            }
-            session.pendingWrites = [];
-        });
-        socket.on("data", (data) => {
-            this.stack?.handleTcpData({ key, data: Buffer.from(data) });
-            this.flush();
-        });
-        socket.on("end", () => {
-            this.stack?.handleTcpEnd({ key });
-            this.flush();
-        });
-        socket.on("close", () => {
-            this.stack?.handleTcpClosed({ key });
-            this.tcpSessions.delete(key);
-        });
-        socket.on("error", () => {
-            this.stack?.handleTcpError({ key });
-            this.tcpSessions.delete(key);
-        });
-    }
-    ensureTlsSession(key, session) {
-        if (session.tls)
-            return session.tls;
-        const stream = new GuestTlsStream((chunk) => {
-            this.stack?.handleTcpData({ key, data: chunk });
-            this.flush();
-        });
-        const tlsSocket = new tls_1.default.TLSSocket(stream, {
-            isServer: true,
-            secureContext: this.getTlsContext(session.dstIP),
-            SNICallback: (servername, callback) => {
-                const sni = servername || session.dstIP;
-                try {
-                    const context = this.getTlsContext(sni);
-                    if (this.options.debug) {
-                        this.emit("log", `[net] tls sni ${sni}`);
-                    }
-                    callback(null, context);
-                }
-                catch (err) {
-                    callback(err);
-                }
-            },
-        });
-        tlsSocket.on("data", (data) => {
-            this.handleTlsHttpData(key, session, Buffer.from(data));
-        });
-        tlsSocket.on("error", (err) => {
-            this.emit("error", err);
-            this.stack?.handleTcpError({ key });
-        });
-        tlsSocket.on("close", () => {
-            this.stack?.handleTcpClosed({ key });
-            this.tcpSessions.delete(key);
-        });
-        session.tls = {
-            stream,
-            socket: tlsSocket,
-            servername: null,
-        };
-        if (this.options.debug) {
-            this.emit("log", `[net] tls mitm start ${session.dstIP}:${session.dstPort}`);
-        }
-        return session.tls;
-    }
-    async handlePlainHttpData(key, session, data) {
-        await this.handleHttpDataWithWriter(key, session, data, {
-            scheme: "http",
-            write: (chunk) => {
-                this.stack?.handleTcpData({ key, data: chunk });
-            },
-            finish: () => {
-                this.stack?.handleTcpEnd({ key });
-                this.flush();
-            },
-        });
-    }
-    async handleTlsHttpData(key, session, data) {
-        const tlsSession = session.tls;
-        if (!tlsSession)
-            return;
-        await this.handleHttpDataWithWriter(key, session, data, {
-            scheme: "https",
-            write: (chunk) => {
-                tlsSession.socket.write(chunk);
-            },
-            finish: () => {
-                tlsSession.socket.end(() => {
-                    this.stack?.handleTcpEnd({ key });
-                    this.flush();
-                });
-            },
-        });
-    }
-    async handleHttpDataWithWriter(key, session, data, options) {
-        const httpSession = session.http ?? {
-            buffer: Buffer.alloc(0),
-            processing: false,
-            closed: false,
-        };
-        session.http = httpSession;
-        if (httpSession.closed)
-            return;
-        httpSession.buffer = Buffer.concat([httpSession.buffer, data]);
-        if (httpSession.processing)
-            return;
-        const parsed = this.parseHttpRequest(httpSession.buffer);
-        if (!parsed)
-            return;
-        httpSession.processing = true;
-        httpSession.buffer = parsed.remaining;
-        try {
-            await this.fetchAndRespond(parsed.request, options.scheme, options.write);
-        }
-        catch (err) {
-            this.emit("error", err instanceof Error ? err : new Error(String(err)));
-            this.respondWithError(options.write, 502, "Bad Gateway");
-        }
-        finally {
-            httpSession.closed = true;
-            options.finish();
-            this.flush();
-        }
-    }
-    handleTlsData(key, session, data) {
-        const tlsSession = this.ensureTlsSession(key, session);
-        if (!tlsSession)
-            return;
-        tlsSession.stream.pushEncrypted(data);
-    }
-    parseHttpRequest(buffer) {
-        const headerEnd = buffer.indexOf("\r\n\r\n");
-        if (headerEnd === -1)
-            return null;
-        const headerBlock = buffer.subarray(0, headerEnd).toString("utf8");
-        const lines = headerBlock.split("\r\n");
-        if (lines.length === 0)
-            return null;
-        const [method, target, version] = lines[0].split(" ");
-        if (!method || !target || !version)
-            return null;
-        const headers = {};
-        for (let i = 1; i < lines.length; i += 1) {
-            const line = lines[i];
-            const idx = line.indexOf(":");
-            if (idx === -1)
-                continue;
-            const key = line.slice(0, idx).trim().toLowerCase();
-            const value = line.slice(idx + 1).trim();
-            if (!key)
-                continue;
-            if (headers[key]) {
-                headers[key] = `${headers[key]}, ${value}`;
-            }
-            else {
-                headers[key] = value;
-            }
-        }
-        const bodyOffset = headerEnd + 4;
-        const bodyBuffer = buffer.subarray(bodyOffset);
-        const transferEncoding = headers["transfer-encoding"]?.toLowerCase();
-        if (transferEncoding === "chunked") {
-            const chunked = this.decodeChunkedBody(bodyBuffer);
-            if (!chunked.complete)
-                return null;
-            return {
-                request: {
-                    method,
-                    target,
-                    version,
-                    headers,
-                    body: chunked.body,
-                },
-                remaining: bodyBuffer.subarray(chunked.bytesConsumed),
-            };
-        }
-        const contentLength = headers["content-length"] ? Number(headers["content-length"]) : 0;
-        if (!Number.isFinite(contentLength) || contentLength < 0)
-            return null;
-        if (bodyBuffer.length < contentLength)
-            return null;
-        return {
-            request: {
-                method,
-                target,
-                version,
-                headers,
-                body: bodyBuffer.subarray(0, contentLength),
-            },
-            remaining: bodyBuffer.subarray(contentLength),
-        };
-    }
-    decodeChunkedBody(buffer) {
-        let offset = 0;
-        const chunks = [];
-        while (true) {
-            const lineEnd = buffer.indexOf("\r\n", offset);
-            if (lineEnd === -1)
-                return { complete: false, body: Buffer.alloc(0), bytesConsumed: 0 };
-            const sizeLine = buffer.subarray(offset, lineEnd).toString("ascii").split(";")[0].trim();
-            const size = parseInt(sizeLine, 16);
-            if (!Number.isFinite(size))
-                return { complete: false, body: Buffer.alloc(0), bytesConsumed: 0 };
-            const chunkStart = lineEnd + 2;
-            const chunkEnd = chunkStart + size;
-            if (buffer.length < chunkEnd + 2)
-                return { complete: false, body: Buffer.alloc(0), bytesConsumed: 0 };
-            if (size > 0) {
-                chunks.push(buffer.subarray(chunkStart, chunkEnd));
-            }
-            if (buffer[chunkEnd] !== 0x0d || buffer[chunkEnd + 1] !== 0x0a) {
-                return { complete: false, body: Buffer.alloc(0), bytesConsumed: 0 };
-            }
-            offset = chunkEnd + 2;
-            if (size === 0) {
-                return { complete: true, body: Buffer.concat(chunks), bytesConsumed: offset };
-            }
-        }
-    }
-    async fetchAndRespond(request, defaultScheme, write) {
-        const url = this.buildFetchUrl(request, defaultScheme);
-        if (!url) {
-            this.respondWithError(write, 400, "Bad Request");
-            return;
-        }
-        if (this.options.debug) {
-            this.emit("log", `[net] http bridge ${request.method} ${url}`);
-        }
-        let hookRequest = {
-            method: request.method,
-            url,
-            headers: this.stripHopByHopHeaders(request.headers),
-            body: request.body.length > 0 ? request.body : null,
-        };
-        if (this.options.httpHooks?.onRequest) {
-            const updated = await this.options.httpHooks.onRequest(hookRequest);
-            if (updated)
-                hookRequest = updated;
-        }
-        const response = await fetch(hookRequest.url, {
-            method: hookRequest.method,
-            headers: hookRequest.headers,
-            body: hookRequest.body ? new Uint8Array(hookRequest.body) : undefined,
-        });
-        if (this.options.debug) {
-            this.emit("log", `[net] http bridge response ${response.status} ${response.statusText}`);
-        }
-        const responseBody = Buffer.from(await response.arrayBuffer());
-        let responseHeaders = this.stripHopByHopHeaders(this.headersToRecord(response.headers));
-        responseHeaders["content-length"] = responseBody.length.toString();
-        responseHeaders["connection"] = "close";
-        let hookResponse = {
-            status: response.status,
-            statusText: response.statusText || "OK",
-            headers: responseHeaders,
-            body: responseBody,
-        };
-        if (this.options.httpHooks?.onResponse) {
-            const updated = await this.options.httpHooks.onResponse(hookResponse, hookRequest);
-            if (updated)
-                hookResponse = updated;
-        }
-        this.sendHttpResponse(write, hookResponse);
-    }
-    sendHttpResponse(write, response) {
-        const statusLine = `HTTP/1.1 ${response.status} ${response.statusText}\r\n`;
-        const headers = Object.entries(response.headers)
-            .map(([name, value]) => `${name}: ${value}`)
-            .join("\r\n");
-        const headerBlock = `${statusLine}${headers}\r\n\r\n`;
-        write(Buffer.from(headerBlock));
-        if (response.body.length > 0) {
-            write(response.body);
-        }
-    }
-    respondWithError(write, status, statusText) {
-        const body = Buffer.from(`${status} ${statusText}\n`);
-        this.sendHttpResponse(write, {
-            status,
-            statusText,
-            headers: {
-                "content-length": body.length.toString(),
-                "content-type": "text/plain",
-                connection: "close",
-            },
-            body,
-        });
-    }
-    buildFetchUrl(request, defaultScheme) {
-        if (request.target.startsWith("http://") || request.target.startsWith("https://")) {
-            return request.target;
-        }
-        const host = request.headers["host"];
-        if (!host)
-            return null;
-        return `${defaultScheme}://${host}${request.target}`;
-    }
-    getMitmDir() {
-        return this.options.mitmCertDir ?? path_1.default.join(process.cwd(), "var", "mitm");
-    }
-    ensureCa() {
-        if (this.caCertPath && this.caKeyPath)
-            return;
-        const mitmDir = this.getMitmDir();
-        fs_1.default.mkdirSync(mitmDir, { recursive: true });
-        const caKeyPath = path_1.default.join(mitmDir, "ca.key");
-        const caCertPath = path_1.default.join(mitmDir, "ca.crt");
-        if (!fs_1.default.existsSync(caKeyPath) || !fs_1.default.existsSync(caCertPath)) {
-            (0, child_process_1.execFileSync)("openssl", [
-                "req",
-                "-x509",
-                "-newkey",
-                "rsa:2048",
-                "-sha256",
-                "-days",
-                "3650",
-                "-nodes",
-                "-subj",
-                "/CN=eregion-mitm-ca",
-                "-keyout",
-                caKeyPath,
-                "-out",
-                caCertPath,
-            ]);
-            if (this.options.debug) {
-                this.emit("log", `[net] generated mitm CA at ${caCertPath}`);
-            }
-        }
-        this.caKeyPath = caKeyPath;
-        this.caCertPath = caCertPath;
-    }
-    getTlsContext(servername) {
-        const normalized = servername.trim() || "unknown";
-        const cached = this.tlsContexts.get(normalized);
-        if (cached)
-            return cached;
-        this.ensureCa();
-        if (!this.caCertPath || !this.caKeyPath) {
-            throw new Error("MITM CA is not initialized");
-        }
-        const { keyPath, certPath } = this.ensureLeafCertificate(normalized);
-        const leafCert = fs_1.default.readFileSync(certPath, "utf8");
-        const caCert = fs_1.default.readFileSync(this.caCertPath, "utf8");
-        const context = tls_1.default.createSecureContext({
-            key: fs_1.default.readFileSync(keyPath),
-            cert: `${leafCert}\n${caCert}`,
-        });
-        this.tlsContexts.set(normalized, context);
-        return context;
-    }
-    ensureLeafCertificate(servername) {
-        if (!this.caCertPath || !this.caKeyPath) {
-            throw new Error("MITM CA is not initialized");
-        }
-        const hostsDir = path_1.default.join(this.getMitmDir(), "hosts");
-        fs_1.default.mkdirSync(hostsDir, { recursive: true });
-        const hash = crypto_1.default.createHash("sha256").update(servername).digest("hex").slice(0, 12);
-        const slug = servername.replace(/[^a-zA-Z0-9.-]/g, "_");
-        const baseName = `${slug || "host"}-${hash}`;
-        const keyPath = path_1.default.join(hostsDir, `${baseName}.key`);
-        const certPath = path_1.default.join(hostsDir, `${baseName}.crt`);
-        if (fs_1.default.existsSync(keyPath) && fs_1.default.existsSync(certPath)) {
-            return { keyPath, certPath };
-        }
-        const csrPath = path_1.default.join(hostsDir, `${baseName}.csr`);
-        const configPath = path_1.default.join(hostsDir, `${baseName}.cnf`);
-        const safeName = servername.replace(/[\r\n]/g, "");
-        const san = net_1.default.isIP(servername) ? `IP:${servername}` : `DNS:${servername}`;
-        const config = [
-            "[req]",
-            "distinguished_name=req_dist",
-            "prompt=no",
-            "req_extensions=v3_req",
-            "[req_dist]",
-            `CN=${safeName}`,
-            "[v3_req]",
-            `subjectAltName=${san}`,
-            "keyUsage=digitalSignature,keyEncipherment",
-            "extendedKeyUsage=serverAuth",
-            "",
-        ].join("\n");
-        fs_1.default.writeFileSync(configPath, config);
-        (0, child_process_1.execFileSync)("openssl", ["genrsa", "-out", keyPath, "2048"]);
-        (0, child_process_1.execFileSync)("openssl", [
-            "req",
-            "-new",
-            "-key",
-            keyPath,
-            "-out",
-            csrPath,
-            "-config",
-            configPath,
-        ]);
-        (0, child_process_1.execFileSync)("openssl", [
-            "x509",
-            "-req",
-            "-in",
-            csrPath,
-            "-CA",
-            this.caCertPath,
-            "-CAkey",
-            this.caKeyPath,
-            "-CAcreateserial",
-            "-out",
-            certPath,
-            "-days",
-            "825",
-            "-sha256",
-            "-extfile",
-            configPath,
-            "-extensions",
-            "v3_req",
-        ]);
-        fs_1.default.rmSync(csrPath, { force: true });
-        fs_1.default.rmSync(configPath, { force: true });
-        return { keyPath, certPath };
-    }
-    stripHopByHopHeaders(headers) {
-        const output = {};
-        for (const [name, value] of Object.entries(headers)) {
-            if (!HOP_BY_HOP_HEADERS.has(name.toLowerCase())) {
-                output[name.toLowerCase()] = value;
-            }
-        }
-        return output;
-    }
-    headersToRecord(headers) {
-        const record = {};
-        headers.forEach((value, key) => {
-            record[key.toLowerCase()] = value;
-        });
-        return record;
-    }
-}
-exports.QemuNetworkBackend = QemuNetworkBackend;