querysub 0.85.0 → 0.87.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.85.0",
+  "version": "0.87.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/-g-core-values/oneTimeForward.ts

@@ -2,6 +2,8 @@ import debugbreak from "debugbreak";
 import * as net from "net";
 import ws from "ws";
 import child_process from "child_process";
+import fs from "fs";
+import path from "path";
 
 // Expose the internal port, via a tcp connection that we forward to internal port, for the first time
 //  externalIP connects to us.
@@ -18,20 +20,35 @@ export async function hackDevtoolsWebsocketForward(config: {
     cancel: () => void;
 }> {
     const forwardCode = ((configInner: typeof config) => {
-        const net = require("net");
+        const net = require("net") as typeof import("net");
+        const fs = require("fs") as typeof import("fs");
+        const path = require("path") as typeof import("path");
         const server = net.createServer();
 
+        const debugFile = path.join(process.env.USERPROFILE || process.env.HOME || "", "debug.temp");
+        //fs.writeFileSync(debugFile, "");
+        const logPacket = (message: string, data?: Buffer) => {
+            // const timestamp = new Date().toISOString();
+            // fs.appendFileSync(
+            //     debugFile,
+            //     `${timestamp} ${message} ${data?.length}\n`
+            // );
+        };
+
         // Start listening on a random available port, binding to all interfaces (0.0.0.0)
         server.listen(0, "0.0.0.0");
 
-        server.on("connection", (socket: net.Socket) => {
+        server.on("connection", (socket) => {
             const clientIP = socket.remoteAddress;
 
+
             if (clientIP !== configInner.externalIP) {
+                logPacket(`Rejected connection attempt from unauthorized IP: ${clientIP}`);
                 console.error(`Rejected connection attempt from unauthorized IP: ${clientIP}`);
                 socket.destroy();
                 return;
             }
+            logPacket(`Accepted connection from ${clientIP}`);
 
             const address = server.address();
             if (!address || typeof address === "string") {
@@ -46,6 +63,7 @@ export async function hackDevtoolsWebsocketForward(config: {
                 port: configInner.internalPort,
             });
             internalConnection.on("data", (data: Buffer) => {
+                logPacket("SENT", data);
                 socket.write(data);
             });
             let first = true;
@@ -57,12 +75,14 @@ export async function hackDevtoolsWebsocketForward(config: {
                     lines[1] = `Host: 127.0.0.1:${configInner.internalPort}`;
                     data = Buffer.from(lines.join("\r\n"));
                 }
+                logPacket("RECEIVED", data);
                 internalConnection.write(data);
             });
 
             // Handle socket closure
             socket.on("close", () => {
                 internalConnection.destroy();
+                logPacket("SENT");
                 // IMPORTANT! We terminate when the connection is closed, which is what makes this safe.
                 process.exit();
             });

package/src/diagnostics/NodeViewer.tsx

@@ -37,6 +37,7 @@ import { SocketRegistered } from "socket-function/SocketFunctionTypes";
 import { ATag } from "../library-components/ATag";
 import { filterURL, selectedNodeId } from "./logs/DiskLoggerPage";
 import { getSyncedController } from "../library-components/SyncedController";
+import child_process from "child_process";
 
 
 type NodeData = {
@@ -348,60 +349,117 @@ class NodeViewerControllerBase {
         let ourIP = await getExternalIP();
         let { externalPort, internalPort, internalInspectURL } = await NodeCapabilitiesController.nodes[nodeId].exposeExternalDebugPortOnce(ourIP);
 
-        let baseNodeIP = getNodeIdIP(nodeId);
-        let baseNodeIPResolved = (await dns.promises.lookup(baseNodeIP)).address;
+        const forwardCode = ((config: {
+            callerIP: string;
+            ourIP: string;
+            externalPort: number;
+            internalPort: number;
+            baseNodeIP: string;
+            cert: { key: string; cert: string; };
+        }) => {
+            const tls = require("tls") as typeof import("tls");
+            const net = require("net") as typeof import("net");
+            const dns = require("dns") as typeof import("dns");
+
+            (async () => {
+                let baseNodeIPResolved = (await dns.promises.lookup(config.baseNodeIP)).address;
+
+                let tlsServer = new tls.Server({
+                    key: config.cert.key,
+                    cert: config.cert.cert,
+                });
+                tlsServer.listen(0, "0.0.0.0");
+                await new Promise((resolve, reject) => {
+                    tlsServer.once("listening", resolve);
+                    tlsServer.once("error", reject);
+                });
+
+                let finalPort = (tlsServer.address() as any).port;
+                console.log(`EXTERNAL_PORT:${finalPort}`);
+
+                tlsServer.on("secureConnection", (socket) => {
+                    let matchedIP = (
+                        socket.remoteAddress === config.callerIP ||
+                        config.callerIP === "127.0.0.1" && socket.remoteAddress === config.ourIP
+                    );
+                    if (!matchedIP) {
+                        console.error(`Rejecting connection from ${socket.remoteAddress}, expected ${config.callerIP} ${config.callerIP === "127.0.0.1" && `or ${config.ourIP}` || ""}`);
+                        socket.end();
+                        return;
+                    }
 
-        // Listen on a websocket, and forward to externalPort:baseNodeIP
-        let cert = await debugGetRawEdgeCert();
+                    let internalConnection = net.createConnection({
+                        host: baseNodeIPResolved,
+                        port: config.externalPort,
+                    });
+                    socket.pipe(internalConnection);
+                    internalConnection.pipe(socket);
 
-        let tlsServer = new tls.Server({
-            key: cert.key,
-            cert: cert.cert,
-        });
-        tlsServer.listen(0, "0.0.0.0");
-        await new Promise((resolve, reject) => {
-            tlsServer.once("listening", resolve);
-            tlsServer.once("error", reject);
+                    socket.on("close", () => {
+                        console.log("Inspect closing forward (socket closed)");
+                        tlsServer.close();
+                        process.exit();
+                    });
+                    internalConnection.on("close", () => {
+                        console.log("Inspect closing forward (internal connection closed)");
+                        tlsServer.close();
+                        process.exit();
+                    });
+                });
+            })().catch(e => {
+                console.error(e);
+                process.exit(1);
+            });
         });
 
-        let finalPort = (tlsServer.address() as any).port;
+        let baseNodeIP = getNodeIdIP(nodeId);
+        let cert = await debugGetRawEdgeCert();
 
-        await forwardPort({ internalPort: finalPort, externalPort: finalPort, });
-        await forwardPort({ internalPort: externalPort, externalPort: externalPort, });
+        const child = child_process.spawn("node", [
+            "-e",
+            `(${forwardCode.toString()})(${JSON.stringify({
+                callerIP,
+                ourIP,
+                externalPort,
+                internalPort,
+                baseNodeIP,
+                cert,
+            })})`,
+        ]);
+
+        let portPromiseResolve: ((port: number) => void) | undefined;
+        const portPromise = new Promise<number>((resolve) => {
+            portPromiseResolve = resolve;
+        });
 
-        tlsServer.on("secureConnection", (socket) => {
-            let matchedIP = (
-                socket.remoteAddress === callerIP ||
-                callerIP === "127.0.0.1" && socket.remoteAddress === ourIP
-            );
-            if (!matchedIP) {
-                console.error(`Rejecting connection from ${socket.remoteAddress}, expected ${callerIP} ${callerIP === "127.0.0.1" && `or ${ourIP}` || ""}`);
-                socket.end();
-                return;
+        let curData = "";
+        child.stdout.on("data", (data) => {
+            console.log(data.toString());
+            curData += data.toString();
+            const match = curData.match(/EXTERNAL_PORT:(\d+)/);
+            if (match && portPromiseResolve) {
+                portPromiseResolve(parseInt(match[1], 10));
             }
+        });
 
-            let internalConnection = net.createConnection({
-                host: baseNodeIPResolved,
-                port: externalPort,
-            });
-            socket.pipe(internalConnection);
-            internalConnection.pipe(socket);
+        child.stderr.on("data", (data) => {
+            console.error(data.toString());
+        });
 
-            socket.on("close", () => {
-                console.log(`Inspect closing forward (socket closed) ${ourDomain}:${finalPort} => ${baseNodeIPResolved}:${externalPort} => 127.0.0.1:${internalPort}, for ${callerIP}`);
-                tlsServer.close();
-            });
-            internalConnection.on("close", () => {
-                console.log(`Inspect closing forward (internal connection closed) ${ourDomain}:${finalPort} => ${baseNodeIPResolved}:${externalPort} => 127.0.0.1:${internalPort}, for ${callerIP}`);
-                tlsServer.close();
-            });
+        child.on("error", (err) => {
+            console.error("Failed to start child process:", err);
+            throw err;
         });
 
+        let finalPort = await portPromise;
+        await forwardPort({ internalPort: finalPort, externalPort: finalPort });
+        await forwardPort({ internalPort: externalPort, externalPort: externalPort });
+
         // Ugh... what a nightmare...
         let ourDomain = ourIP.replaceAll(".", "-") + "." + getDomain();
         await setRecord("A", ourDomain, ourIP);
 
-        console.log(`Inspect forward ${ourDomain}:${finalPort} => ${baseNodeIPResolved}:${externalPort} => 127.0.0.1:${internalPort}, for ${callerIP}`);
+        console.log(`Inspect forward ${ourDomain}:${finalPort} => ${baseNodeIP}:${externalPort} => 127.0.0.1:${internalPort}, for ${callerIP}`);
 
         return internalInspectURL.replace(`ws=127.0.0.1:${internalPort}`, `wss=${ourDomain}:${finalPort}`);
     }