@suveren/gateway 0.26.0 → 0.27.0

package/dist/control-plane/index.mjs

@@ -3578,6 +3578,106 @@ function createEvidenceExportRouter(spUrl, vault2, dataDir, lockAsTlsMismatch2)
 // src/routes/proposal-preview.ts
 import { Router as Router10 } from "express";
 
+// src/lib/content-crypto.ts
+import { createHash as createHash4 } from "crypto";
+import { canonicalize as canonicalize2 } from "@hap/core";
+var CONTENT_ALG = "HPKE-X25519-HKDF-SHA256-AES256GCM";
+function computeProposalContentHash(toolArgs) {
+  return `sha256:${createHash4("sha256").update(canonicalize2(toolArgs)).digest("hex")}`;
+}
+function toB64(bytes) {
+  return Buffer.from(bytes).toString("base64");
+}
+function keysToWire(encryptedKeys) {
+  const keys = {};
+  for (const [userId, wrap] of Object.entries(encryptedKeys)) {
+    keys[userId] = { ct: toB64(wrap.ct), enc: toB64(wrap.enc) };
+  }
+  return keys;
+}
+async function fetchUserPubkey(userId, deps) {
+  const pin = readPairing(deps.dataDir);
+  const pinning = {
+    enforce: resolvePinTls(deps.dataDir),
+    pinnedSpkiHex: pin && pin.asUrl === deps.spUrl ? pin.tlsSpkiPinHex : void 0
+  };
+  try {
+    const { res } = await fetchAs(
+      `${deps.spUrl}/api/users/${encodeURIComponent(userId)}/pubkey`,
+      { headers: { Cookie: deps.cookie }, signal: AbortSignal.timeout(5e3) },
+      pinning
+    );
+    if (!res.ok) return null;
+    const data = await res.json().catch(() => ({}));
+    return typeof data.pubkey === "string" ? data.pubkey : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveRecipientPubkeys(recipientUserIds, deps) {
+  const ids = Array.from(/* @__PURE__ */ new Set([deps.selfUserId, ...recipientUserIds]));
+  const resolved = [];
+  const unreadableFor = [];
+  for (const userId of ids) {
+    const pubkeyB64 = await fetchUserPubkey(userId, deps);
+    if (!pubkeyB64) {
+      unreadableFor.push(userId);
+      continue;
+    }
+    try {
+      const bytes = new Uint8Array(Buffer.from(pubkeyB64, "base64"));
+      if (bytes.length !== 32) {
+        unreadableFor.push(userId);
+        continue;
+      }
+      resolved.push({ userId, publicKey: bytes });
+    } catch {
+      unreadableFor.push(userId);
+    }
+  }
+  return { resolved, unreadableFor };
+}
+async function encryptProposalContent(toolArgs, recipientUserIds, deps) {
+  const canonical = canonicalize2(toolArgs);
+  const hash = computeProposalContentHash(toolArgs);
+  const { resolved, unreadableFor } = await resolveRecipientPubkeys(recipientUserIds, deps);
+  if (resolved.length === 0) {
+    throw new Error("No recipient (including the submitter) has a registered end-to-end key \u2014 cannot encrypt this proposal.");
+  }
+  const encrypted = await encryptForRecipients(canonical, resolved);
+  return {
+    content: { v: 1, alg: CONTENT_ALG, ciphertext: toB64(encrypted.intentCiphertext), keys: keysToWire(encrypted.encryptedKeys), hash },
+    unreadableFor
+  };
+}
+async function encryptProposalNote(note, recipientUserIds, deps) {
+  const { resolved, unreadableFor } = await resolveRecipientPubkeys(recipientUserIds, deps);
+  if (resolved.length === 0) {
+    throw new Error("No recipient (including the submitter) has a registered end-to-end key \u2014 cannot encrypt this note.");
+  }
+  const encrypted = await encryptForRecipients(note, resolved);
+  return {
+    noteEncrypted: { ciphertext: toB64(encrypted.intentCiphertext), keys: keysToWire(encrypted.encryptedKeys) },
+    unreadableFor
+  };
+}
+async function decryptProposalContent(wire, myUserId, myPrivateKey) {
+  const wrap = wire.keys[myUserId];
+  if (!wrap) {
+    throw new Error("No key wrap for this account in this content \u2014 this device cannot read it.");
+  }
+  const encrypted = {
+    intentCiphertext: new Uint8Array(Buffer.from(wire.ciphertext, "base64")),
+    encryptedKeys: {
+      [myUserId]: {
+        ct: new Uint8Array(Buffer.from(wrap.ct, "base64")),
+        enc: new Uint8Array(Buffer.from(wrap.enc, "base64"))
+      }
+    }
+  };
+  return decryptIntent(encrypted, myUserId, myPrivateKey);
+}
+
 // src/lib/execution-journal-reader.ts
 import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
 import { join as join10 } from "path";
@@ -3644,8 +3744,25 @@ function createProposalStatusRouter(spUrl, vault2, dataDir, lockAsTlsMismatch2)
       res.status(502).json({ error: `Authority Server unreachable: ${err instanceof Error ? err.message : String(err)}` });
       return;
     }
+    let toolArgs;
+    if (proposal.toolArgs) {
+      toolArgs = proposal.toolArgs;
+    } else if (proposal.content) {
+      try {
+        const kp = await loadOrGenerateKeyPair(vault2);
+        const me = vault2.getSessionUser();
+        const plaintext = await decryptProposalContent(proposal.content, me?.id ?? "", kp.privateKey);
+        toolArgs = JSON.parse(plaintext);
+      } catch (err) {
+        res.json({ status: "unavailable", reason: "connector_error", message: `Could not decrypt this proposal's content on this device: ${err instanceof Error ? err.message : String(err)}` });
+        return;
+      }
+    } else {
+      res.status(502).json({ error: `Proposal ${proposalId} carries neither tool_args nor content.` });
+      return;
+    }
     try {
-      const result = await getToolPreview({ proposalId, tool: proposal.tool, toolArgs: proposal.toolArgs });
+      const result = await getToolPreview({ proposalId, tool: proposal.tool, toolArgs });
       if (result.status !== "ok") {
         res.json(result);
         return;
@@ -3691,7 +3808,7 @@ function createProposalStatusRouter(spUrl, vault2, dataDir, lockAsTlsMismatch2)
 // src/routes/evidence.ts
 import { Router as Router11 } from "express";
 import { createPublicKey as createPublicKey2, verify as verifyEd25519 } from "crypto";
-import { verifyTicketSignature, encodeDidKey, canonicalize as canonicalize2 } from "@hap/core";
+import { verifyTicketSignature, encodeDidKey, canonicalize as canonicalize3 } from "@hap/core";
 function issuerFromPublicKeyHex(publicKeyHex) {
   return encodeDidKey(Buffer.from(publicKeyHex, "hex"));
 }
@@ -3710,7 +3827,7 @@ function verifyPreV07TicketSignature(receipt, asPublicKeyHex) {
     });
     const sig = Buffer.from(signature, "base64");
     if (sig.length !== 64) return false;
-    return verifyEd25519(null, Buffer.from(canonicalize2(signed), "utf8"), key, sig);
+    return verifyEd25519(null, Buffer.from(canonicalize3(signed), "utf8"), key, sig);
   } catch {
     return false;
   }
@@ -3922,6 +4039,161 @@ function createDecryptIntentRouter(vault2) {
   return router;
 }
 
+// src/routes/decrypt-proposal-content.ts
+import { Router as Router14 } from "express";
+function createDecryptProposalContentRouter(vault2) {
+  const router = Router14();
+  router.post("/", async (req, res) => {
+    const { ciphertext, keys } = req.body;
+    if (typeof ciphertext !== "string" || ciphertext.length === 0) {
+      res.status(400).json({ error: "Missing or invalid field: ciphertext (base64 string)" });
+      return;
+    }
+    if (typeof keys !== "object" || keys === null) {
+      res.status(400).json({ error: "Missing or invalid field: keys (object)" });
+      return;
+    }
+    const me = vault2.getSessionUser();
+    if (!me) {
+      res.status(401).json({ error: "No Authority Server session." });
+      return;
+    }
+    try {
+      const kp = await loadOrGenerateKeyPair(vault2);
+      const plaintext = await decryptProposalContent(
+        { ciphertext, keys },
+        me.id,
+        kp.privateKey
+      );
+      res.json({ plaintext });
+    } catch (err) {
+      console.error("[Control Plane] decrypt-proposal-content error:", err);
+      const msg = err instanceof Error ? err.message : "Decryption failed";
+      res.status(msg.includes("No key wrap") ? 403 : 500).json({ error: msg });
+    }
+  });
+  return router;
+}
+
+// src/routes/encrypt-proposal-note.ts
+import { Router as Router15 } from "express";
+var MAX_NOTE_LENGTH = 500;
+function createEncryptProposalNoteRouter(vault2, spUrl, dataDir) {
+  const router = Router15();
+  router.post("/", async (req, res) => {
+    const { note, recipientUserIds } = req.body;
+    if (typeof note !== "string" || note.length === 0 || note.length > MAX_NOTE_LENGTH) {
+      res.status(400).json({ error: `note must be a non-empty string up to ${MAX_NOTE_LENGTH} characters` });
+      return;
+    }
+    if (!Array.isArray(recipientUserIds) || !recipientUserIds.every((id) => typeof id === "string")) {
+      res.status(400).json({ error: "recipientUserIds must be a string array" });
+      return;
+    }
+    const me = vault2.getSessionUser();
+    const cookie = vault2.getSpCookie();
+    if (!me || !cookie) {
+      res.status(401).json({ error: "No Authority Server session." });
+      return;
+    }
+    try {
+      const { noteEncrypted, unreadableFor } = await encryptProposalNote(
+        note,
+        recipientUserIds,
+        { spUrl, cookie, dataDir, selfUserId: me.id }
+      );
+      res.json({ noteEncrypted, unreadableFor });
+    } catch (err) {
+      console.error("[Control Plane] encrypt-proposal-note error:", err);
+      res.status(500).json({ error: err instanceof Error ? err.message : "Encryption failed" });
+    }
+  });
+  return router;
+}
+
+// src/routes/internal-content-crypto.ts
+import { Router as Router16 } from "express";
+import { timingSafeEqual as timingSafeEqual2 } from "crypto";
+var MAX_RECIPIENTS = 50;
+function secretMatches(provided, expected) {
+  if (!expected || !provided) return false;
+  const a = Buffer.from(provided);
+  const b = Buffer.from(expected);
+  return a.length === b.length && timingSafeEqual2(a, b);
+}
+function createInternalContentCryptoRouter(getSecret, vault2, spUrl, dataDir) {
+  const router = Router16();
+  router.post("/encrypt-content", async (req, res) => {
+    if (!secretMatches(req.header("X-Internal-Secret") ?? void 0, getSecret())) {
+      res.status(401).json({ error: "unauthorized" });
+      return;
+    }
+    const { toolArgs, recipientUserIds } = req.body ?? {};
+    if (typeof toolArgs !== "object" || toolArgs === null || Array.isArray(toolArgs)) {
+      res.status(400).json({ error: "toolArgs must be an object" });
+      return;
+    }
+    if (!Array.isArray(recipientUserIds) || !recipientUserIds.every((id) => typeof id === "string")) {
+      res.status(400).json({ error: "recipientUserIds must be a string array" });
+      return;
+    }
+    if (recipientUserIds.length > MAX_RECIPIENTS) {
+      res.status(400).json({ error: `too many recipients (max ${MAX_RECIPIENTS})` });
+      return;
+    }
+    const me = vault2.getSessionUser();
+    const cookie = vault2.getSpCookie();
+    if (!me || !cookie) {
+      res.status(401).json({ error: "no Authority Server session" });
+      return;
+    }
+    try {
+      const { content, unreadableFor } = await encryptProposalContent(
+        toolArgs,
+        recipientUserIds,
+        { spUrl, cookie, dataDir, selfUserId: me.id }
+      );
+      res.json({ content, unreadableFor });
+    } catch (err) {
+      console.error("[Control Plane] /internal/encrypt-content failed:", err);
+      res.status(500).json({ error: err instanceof Error ? err.message : "encryption failed" });
+    }
+  });
+  router.post("/decrypt-content", async (req, res) => {
+    if (!secretMatches(req.header("X-Internal-Secret") ?? void 0, getSecret())) {
+      res.status(401).json({ error: "unauthorized" });
+      return;
+    }
+    const { ciphertext, keys } = req.body ?? {};
+    if (typeof ciphertext !== "string" || ciphertext.length === 0) {
+      res.status(400).json({ error: "ciphertext (base64 string) is required" });
+      return;
+    }
+    if (typeof keys !== "object" || keys === null) {
+      res.status(400).json({ error: "keys (object) is required" });
+      return;
+    }
+    const me = vault2.getSessionUser();
+    if (!me) {
+      res.status(401).json({ error: "no Authority Server session" });
+      return;
+    }
+    try {
+      const kp = await loadOrGenerateKeyPair(vault2);
+      const plaintext = await decryptProposalContent(
+        { ciphertext, keys },
+        me.id,
+        kp.privateKey
+      );
+      res.json({ plaintext });
+    } catch (err) {
+      console.error("[Control Plane] /internal/decrypt-content failed:", err);
+      res.status(500).json({ error: err instanceof Error ? err.message : "decryption failed" });
+    }
+  });
+  return router;
+}
+
 // src/lib/update-checker.ts
 import { execSync } from "child_process";
 import { dirname as dirname6 } from "path";
@@ -4060,7 +4332,7 @@ data: ${data}
 }
 
 // src/routes/gateway-settings.ts
-import { Router as Router14 } from "express";
+import { Router as Router17 } from "express";
 
 // src/lib/gateway-settings.ts
 import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6 } from "fs";
@@ -4096,7 +4368,7 @@ function writeSettings(patch, dataDir) {
 
 // src/routes/gateway-settings.ts
 function createGatewaySettingsRouter() {
-  const router = Router14();
+  const router = Router17();
   router.get("/", (_req, res) => {
     res.json(readSettings());
   });
@@ -4119,7 +4391,7 @@ function createGatewaySettingsRouter() {
 }
 
 // src/routes/archived-mandates.ts
-import { Router as Router15 } from "express";
+import { Router as Router18 } from "express";
 
 // src/lib/archived-mandates-store.ts
 import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, renameSync } from "fs";
@@ -4162,7 +4434,7 @@ function unarchiveMandate(id, dataDir) {
 
 // src/routes/archived-mandates.ts
 function createArchivedMandatesRouter(dataDir) {
-  const router = Router15();
+  const router = Router18();
   router.get("/", (_req, res) => {
     res.json({ archived: readArchived(dataDir) });
   });
@@ -4184,24 +4456,24 @@ function createArchivedMandatesRouter(dataDir) {
 }
 
 // src/routes/internal-events.ts
-import { Router as Router16 } from "express";
-import { timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { Router as Router19 } from "express";
+import { timingSafeEqual as timingSafeEqual3 } from "crypto";
 var ALLOWED = ["proposal-added", "action-approval-needed"];
 var SESSION_EXPIRED = "session-expired";
 var AS_KEY_MISMATCH = "as-key-mismatch";
 var AS_TLS_MISMATCH = "as-tls-mismatch";
-function secretMatches(provided, expected) {
+function secretMatches2(provided, expected) {
   if (!expected) return false;
   if (!provided) return false;
   const a = Buffer.from(provided);
   const b = Buffer.from(expected);
   if (a.length !== b.length) return false;
-  return timingSafeEqual2(a, b);
+  return timingSafeEqual3(a, b);
 }
 function createInternalEventsRouter(getSecret, onSessionExpired, onAsKeyMismatch, onAsTlsMismatch) {
-  const router = Router16();
+  const router = Router19();
   router.post("/event", (req, res) => {
-    if (!secretMatches(req.headers["x-internal-secret"], getSecret())) {
+    if (!secretMatches2(req.headers["x-internal-secret"], getSecret())) {
       res.status(401).json({ error: "Unauthorized" });
       return;
     }
@@ -4233,8 +4505,8 @@ function createInternalEventsRouter(getSecret, onSessionExpired, onAsKeyMismatch
 }
 
 // src/routes/internal-mandate.ts
-import { Router as Router17 } from "express";
-import { timingSafeEqual as timingSafeEqual3, randomUUID } from "crypto";
+import { Router as Router20 } from "express";
+import { timingSafeEqual as timingSafeEqual4, randomUUID } from "crypto";
 
 // src/lib/mandate-ceremony.ts
 import {
@@ -4408,16 +4680,16 @@ async function createMandate(req, deps) {
 }
 
 // src/routes/internal-mandate.ts
-function secretMatches2(provided, expected) {
+function secretMatches3(provided, expected) {
   if (!expected || !provided) return false;
   const a = Buffer.from(provided);
   const b = Buffer.from(expected);
-  return a.length === b.length && timingSafeEqual3(a, b);
+  return a.length === b.length && timingSafeEqual4(a, b);
 }
 function createInternalMandateRouter(getSecret, deps) {
-  const router = Router17();
+  const router = Router20();
   router.post("/mandate", async (req, res) => {
-    if (!secretMatches2(req.header("X-Internal-Secret") ?? void 0, getSecret())) {
+    if (!secretMatches3(req.header("X-Internal-Secret") ?? void 0, getSecret())) {
       res.status(401).json({ error: "unauthorized" });
       return;
     }
@@ -4954,6 +5226,7 @@ app.use("/internal", jsonParser, createInternalMandateRouter(() => internalSecre
   encrypt: encryptIntentForRecipients,
   deliverGateContent: (args) => pushGateContent(args)
 })));
+app.use("/internal", jsonParser, createInternalContentCryptoRouter(() => internalSecret2, vault, SP_URL, DATA_DIR));
 app.use("/vault", jsonParser, authGuard, createVaultRouter(vault));
 app.use("/ai", jsonParser, authGuard, createAIRouter(vault));
 app.use("/ai-prompts", jsonParser, authGuard, createAIPromptsRouter());
@@ -4967,6 +5240,8 @@ app.use("/proposal-status", authGuard, createProposalStatusRouter(SP_URL, vault,
 app.use("/api/evidence", authGuard, createEvidenceRouter());
 app.use("/api/report", jsonParser, authGuard, createReportRouter(() => RUNNING_VERSION));
 app.use("/api/decrypt-intent", jsonParser, authGuard, createDecryptIntentRouter(vault));
+app.use("/api/decrypt-proposal-content", jsonParser, authGuard, createDecryptProposalContentRouter(vault));
+app.use("/api/encrypt-proposal-note", jsonParser, authGuard, createEncryptProposalNoteRouter(vault, SP_URL, DATA_DIR));
 app.use("/api/approved-intents", jsonParser, authGuard, createApprovedIntentsRouter(vault));
 app.put("/integrations/:id/read-policy", jsonParser, authGuard, async (req, res) => {
   const id = req.params.id;