@mrciphersmith/keryx 0.4.4 → 0.4.6

package/dist/proxy-worker.js

@@ -6,6 +6,7 @@ import { parentPort, workerData } from "worker_threads";
 import http from "http";
 import https from "https";
 import net from "net";
+import { PassThrough } from "stream";
 import dns from "dns";
 import { unlinkSync } from "fs";
 
@@ -18,6 +19,21 @@ var HARD_DENY_RISKS = new Set([
 ]);
 
 // src/harness/mutation/guard.ts
+var ADDR_START = "(?<![\\w.-])";
+var PRIVATE_EGRESS_PATTERNS = [
+  /localhost/i,
+  /::1(?![0-9a-f])/i,
+  new RegExp(`${ADDR_START}127\\.\\d`),
+  /(?<!\d)2130706433(?!\d)/,
+  /0x0*7f/i,
+  /(?<!\d)0177\./,
+  new RegExp(`${ADDR_START}169\\.254\\.`),
+  new RegExp(`${ADDR_START}10\\.\\d`),
+  new RegExp(`${ADDR_START}172\\.(1[6-9]|2\\d|3[01])\\.`),
+  new RegExp(`${ADDR_START}192\\.168\\.`),
+  new RegExp(`${ADDR_START}0\\.0\\.0\\.0(?!\\d)`),
+  new RegExp(`${ADDR_START}100\\.(6[4-9]|[7-9]\\d|1[01]\\d|12[0-7])\\.`)
+];
 var MAX_U32 = 4294967295;
 function u32ToOctets(n) {
   return [n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255];
@@ -147,6 +163,7 @@ function decodeEncodedIPv4(candidate) {
 var ENV_DUMP_ARGV = new Set(["env", "printenv"]);
 
 // src/harness/process/sandbox/proxy.ts
+var MAX_TERMINATORS = 64;
 function normalizeHost(host) {
   return host.toLowerCase().replace(/\.$/, "");
 }
@@ -226,6 +243,17 @@ function applyMasks(headers, masks, hostname) {
   }
   return out;
 }
+function carriesSentinel(headers, masks, hostname) {
+  const applicable = masks.filter((m) => m.sentinel.length > 0 && matchesAllowlist(hostname, m.injectHosts));
+  if (applicable.length === 0)
+    return false;
+  for (const value of Object.values(headers)) {
+    const values = Array.isArray(value) ? value : value === undefined ? [] : [value];
+    if (values.some((v) => applicable.some((m) => v.includes(m.sentinel))))
+      return true;
+  }
+  return false;
+}
 function httpTarget(req) {
   const raw = req.url ?? "";
   try {
@@ -253,6 +281,17 @@ function httpTarget(req) {
   }
   return { kind: "no-target" };
 }
+function listenOrReject(server, listen) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => reject(error);
+    server.once("error", onError);
+    server.once("listening", () => {
+      server.off("error", onError);
+      resolve();
+    });
+    listen();
+  });
+}
 async function createAllowlistProxy(opts) {
   const host = opts.host ?? "127.0.0.1";
   const allowed = opts.allowedDomains;
@@ -287,9 +326,13 @@ async function createAllowlistProxy(opts) {
       refuse(`port ${target.port} is not allowed`);
       return;
     }
+    if (carriesSentinel(req.headers, opts.masks ?? [], target.hostname)) {
+      refuse("credential sentinel over plaintext HTTP");
+      return;
+    }
     const proceed = (connectHost) => {
       decide({ host: hostname, allowed: true, kind: "http", port: target.port });
-      const headers = applyMasks(req.headers, opts.masks ?? [], target.hostname);
+      const headers = req.headers;
       const upstream = trySync(() => http.request({ host: connectHost, port: target.port, method: req.method, path: pathFromUrl(req.url), headers: { ...headers, host: target.hostname } }, (up) => {
         res.writeHead(up.statusCode ?? 502, up.headers);
         up.pipe(res);
@@ -357,19 +400,46 @@ async function createAllowlistProxy(opts) {
     req.pipe(upstreamReq);
   };
   const mitmServers = new Map;
+  const closeTerminator = (entry) => entry.then(({ server: s }) => new Promise((resolve) => s.close(() => resolve())), () => {
+    return;
+  });
   const mitmPortFor = async (hostname, targetPort, ca) => {
     const host = normalizeHost(hostname);
     const key = `${host}:${targetPort}`;
     const hit = mitmServers.get(key);
-    if (hit)
-      return hit.port;
-    const leaf = await ca.issueLeaf(host);
-    const server = https.createServer({ key: leaf.keyPem, cert: leaf.certPem }, makeMitmHandler(host, targetPort));
-    await new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve()));
-    const addr = server.address();
-    const port = addr && typeof addr === "object" ? addr.port : 0;
-    mitmServers.set(key, { server, port });
-    return port;
+    if (hit) {
+      mitmServers.delete(key);
+      mitmServers.set(key, hit);
+      return (await hit).port;
+    }
+    const created = (async () => {
+      const leaf = await ca.issueLeaf(host);
+      const terminator = https.createServer({ key: leaf.keyPem, cert: leaf.certPem }, makeMitmHandler(host, targetPort));
+      await new Promise((resolve, reject) => {
+        terminator.once("error", reject);
+        terminator.listen(0, "127.0.0.1", () => {
+          terminator.off("error", reject);
+          resolve();
+        });
+      });
+      const addr = terminator.address();
+      return { server: terminator, port: addr && typeof addr === "object" ? addr.port : 0 };
+    })();
+    mitmServers.set(key, created);
+    created.catch(() => {
+      if (mitmServers.get(key) === created)
+        mitmServers.delete(key);
+    });
+    while (mitmServers.size > MAX_TERMINATORS) {
+      const oldest = mitmServers.keys().next().value;
+      if (oldest === undefined || oldest === key)
+        break;
+      const evicted = mitmServers.get(oldest);
+      mitmServers.delete(oldest);
+      if (evicted)
+        closeTerminator(evicted);
+    }
+    return (await created).port;
   };
   server.on("connect", (req, clientSocket, head) => {
     const url = req.url ?? "";
@@ -397,24 +467,41 @@ async function createAllowlistProxy(opts) {
       refuse(`port ${port} is not allowed`);
       return;
     }
+    const pending = new PassThrough;
+    clientSocket.pipe(pending);
+    const onPendingEnd = () => {
+      clientSocket.destroy();
+    };
+    clientSocket.once("end", onPendingEnd);
+    clientSocket.once("close", () => pending.destroy());
     const proceed = (connectHost) => {
+      if (clientSocket.destroyed)
+        return;
       decide({ host: hostname, allowed: true, kind: "connect", port });
       const ca = opts.tlsTerminate;
       if (ca) {
         (async () => {
           try {
             const terminatorPort = await mitmPortFor(hostname, port, ca);
+            if (clientSocket.destroyed)
+              return;
             clientSocket.write(`HTTP/1.1 200 Connection Established\r
 \r
 `);
             const internal = net.connect(terminatorPort, "127.0.0.1", () => {
+              if (clientSocket.destroyed) {
+                internal.destroy();
+                return;
+              }
+              clientSocket.off("end", onPendingEnd);
               if (head && head.length > 0)
                 internal.write(head);
-              clientSocket.pipe(internal);
+              pending.pipe(internal);
               internal.pipe(clientSocket);
             });
             internal.on("error", () => clientSocket.destroy());
             clientSocket.on("error", () => internal.destroy());
+            clientSocket.on("close", () => internal.destroy());
           } catch {
             clientSocket.write(`HTTP/1.1 502 Bad Gateway\r
 \r
@@ -425,13 +512,18 @@ async function createAllowlistProxy(opts) {
         return;
       }
       const onUpstreamConnect = (upstream) => {
+        if (clientSocket.destroyed) {
+          upstream.destroy();
+          return;
+        }
+        clientSocket.off("end", onPendingEnd);
         clientSocket.write(`HTTP/1.1 200 Connection Established\r
 \r
 `);
         if (head && head.length > 0)
           upstream.write(head);
         upstream.pipe(clientSocket);
-        clientSocket.pipe(upstream);
+        pending.pipe(upstream);
       };
       const onUpstreamFailure = () => {
         clientSocket.write(`HTTP/1.1 502 Bad Gateway\r
@@ -445,6 +537,7 @@ async function createAllowlistProxy(opts) {
       upstream.once("connect", () => onUpstreamConnect(upstream));
       upstream.on("error", onUpstreamFailure);
       clientSocket.on("error", () => upstream.destroy());
+      clientSocket.on("close", () => upstream.destroy());
     };
     if (!hardened) {
       proceed(hostname);
@@ -461,9 +554,9 @@ async function createAllowlistProxy(opts) {
     try {
       unlinkSync(opts.unixSocketPath);
     } catch {}
-    await new Promise((resolve) => server.listen(opts.unixSocketPath, () => resolve()));
+    await listenOrReject(server, () => server.listen(opts.unixSocketPath));
   } else {
-    await new Promise((resolve) => server.listen(opts.port ?? 0, host, () => resolve()));
+    await listenOrReject(server, () => server.listen(opts.port ?? 0, host));
   }
   const addr = server.address();
   const port = addr && typeof addr === "object" && addr !== null ? addr.port : 0;
@@ -473,8 +566,9 @@ async function createAllowlistProxy(opts) {
     ...opts.unixSocketPath !== undefined ? { unixSocketPath: opts.unixSocketPath } : {},
     close: async () => {
       await new Promise((resolve) => server.close(() => resolve()));
-      await Promise.all([...mitmServers.values()].map(({ server: s }) => new Promise((resolve) => s.close(() => resolve()))));
+      const terminators = [...mitmServers.values()];
       mitmServers.clear();
+      await Promise.all(terminators.map(closeTerminator));
     }
   };
 }
@@ -491,9 +585,12 @@ function pathFromUrl(url) {
 
 // src/harness/process/sandbox/tls-ca.ts
 import { spawn } from "child_process";
+import { randomBytes } from "crypto";
 import { mkdtemp, mkdir, readFile, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import path from "path";
+var MAX_CACHED_LEAVES = 64;
+var MAX_CONCURRENT_ISSUANCES = 4;
 function run(bin, args) {
   return new Promise((resolve, reject) => {
     const proc = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
@@ -505,6 +602,12 @@ function run(bin, args) {
     proc.on("close", (code) => code === 0 ? resolve(out) : reject(new Error(`${bin} ${args[0]} failed (exit ${code}): ${err.trim()}`)));
   });
 }
+function randomSerial() {
+  const bytes = randomBytes(16);
+  bytes[0] = (bytes[0] ?? 0) & 127;
+  bytes[15] = (bytes[15] ?? 0) | 1;
+  return `0x${bytes.toString("hex")}`;
+}
 var CA_CONFIG = `[req]
 distinguished_name = dn
 x509_extensions = v3_ca
@@ -562,18 +665,38 @@ async function createRunCa(options = {}) {
   ]);
   const caCertPem = await readFile(caCert, "utf8");
   const cache = new Map;
-  return {
-    caCertPem,
-    async issueLeaf(host) {
-      const key = host.toLowerCase();
-      const hit = cache.get(key);
-      if (hit)
-        return hit;
-      const safe = key.replace(/[^a-z0-9.-]/g, "_");
-      const leafKey = path.join(root, `${safe}.key`);
-      const leafCsr = path.join(root, `${safe}.csr`);
-      const leafCrt = path.join(root, `${safe}.crt`);
-      const leafCfg = path.join(root, `${safe}.cnf`);
+  const inflight = new Map;
+  let running = 0;
+  const waiting = [];
+  const acquire = () => {
+    if (running < MAX_CONCURRENT_ISSUANCES) {
+      running += 1;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => waiting.push(resolve));
+  };
+  const release = () => {
+    const next = waiting.shift();
+    if (next)
+      next();
+    else
+      running -= 1;
+  };
+  const issueLimited = async (key) => {
+    await acquire();
+    try {
+      return await issue(key);
+    } finally {
+      release();
+    }
+  };
+  const issue = async (key) => {
+    const work = await mkdtemp(path.join(root, "leaf-"));
+    try {
+      const leafKey = path.join(work, "leaf.key");
+      const leafCsr = path.join(work, "leaf.csr");
+      const leafCrt = path.join(work, "leaf.crt");
+      const leafCfg = path.join(work, "leaf.cnf");
       await writeFile(leafCfg, leafConfig(key), { mode: 384 });
       await run(openssl, [
         "req",
@@ -597,7 +720,8 @@ async function createRunCa(options = {}) {
         caCert,
         "-CAkey",
         caKey,
-        "-CAcreateserial",
+        "-set_serial",
+        randomSerial(),
         "-out",
         leafCrt,
         "-days",
@@ -607,15 +731,47 @@ async function createRunCa(options = {}) {
         "-extensions",
         "v3_req"
       ]);
-      const issued = {
+      return {
         certPem: await readFile(leafCrt, "utf8"),
         keyPem: await readFile(leafKey, "utf8")
       };
-      cache.set(key, issued);
-      return issued;
+    } finally {
+      await rm(work, { recursive: true, force: true });
+    }
+  };
+  return {
+    caCertPem,
+    issueLeaf(host) {
+      const key = host.toLowerCase();
+      const hit = cache.get(key);
+      if (hit) {
+        cache.delete(key);
+        cache.set(key, hit);
+        return Promise.resolve(hit);
+      }
+      const pending = inflight.get(key);
+      if (pending)
+        return pending;
+      const started = issueLimited(key).then((issued) => {
+        cache.set(key, issued);
+        while (cache.size > MAX_CACHED_LEAVES) {
+          const oldest = cache.keys().next().value;
+          if (oldest === undefined)
+            break;
+          cache.delete(oldest);
+        }
+        inflight.delete(key);
+        return issued;
+      }, (error) => {
+        inflight.delete(key);
+        throw error;
+      });
+      inflight.set(key, started);
+      return started;
     },
     async dispose() {
       cache.clear();
+      inflight.clear();
       await rm(root, { recursive: true, force: true });
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrciphersmith/keryx",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Version-controlled project context for AI coding agents: code graph, architecture wiki, project memory, relevant tests, quality signals, and task flows.",
   "private": false,
   "publishConfig": {