@sandprivacy/sandgate 0.3.0 → 0.3.1

package/dist/index.js

@@ -423,9 +423,12 @@ async function cmdTestApproval() {
     const data = loadVault(pass);
     let approver;
     if (data.pwa) {
-        const { PwaApprover } = await import("./pwa-approver.js");
-        approver = new PwaApprover(data.pwa);
-        console.log("Sending test approval to the paired PWA (60s timeout)…");
+        const { pwaApproverFrom } = await import("./pwa-approver.js");
+        const config = loadConfig();
+        approver = pwaApproverFrom(data, config);
+        console.log(config.requireBiometric
+            ? "Sending test approval to the paired PWA — Face ID required (60s timeout)…"
+            : "Sending test approval to the paired PWA (60s timeout)…");
     }
     else if (data.telegram) {
         approver = new TelegramApprover(data.telegram.botToken, data.telegram.chatId);

package/dist/pwa-approver.js

@@ -101,3 +101,17 @@ export class PwaApprover {
         });
     }
 }
+/**
+ * Build the PWA approver from vault + config. Everything that talks to the
+ * phone goes through here: when `serve` and the CLI each assembled their
+ * own config, the CLI silently lost biometric enforcement.
+ */
+export function pwaApproverFrom(vault, config) {
+    if (!vault.pwa)
+        return null;
+    return new PwaApprover({
+        ...vault.pwa,
+        biometric: vault.biometric,
+        requireBiometric: config.requireBiometric,
+    });
+}

package/dist/server.js

@@ -5,7 +5,7 @@ import { loadVault } from "./vault.js";
 import { loadConfig, totpPolicy } from "./config.js";
 import { generateCode } from "./totp.js";
 import { TelegramApprover } from "./telegram.js";
-import { PwaApprover } from "./pwa-approver.js";
+import { pwaApproverFrom } from "./pwa-approver.js";
 import { backendFromVault } from "./inbox.js";
 import { audit } from "./audit.js";
 /**
@@ -29,11 +29,7 @@ export async function serve(passphrase) {
     }
     // PWA (E2EE push) wins over Telegram when both are configured.
     const approver = vault.pwa
-        ? new PwaApprover({
-            ...vault.pwa,
-            biometric: vault.biometric,
-            requireBiometric: config.requireBiometric,
-        })
+        ? pwaApproverFrom(vault, config)
         : vault.telegram
             ? new TelegramApprover(vault.telegram.botToken, vault.telegram.chatId)
             : null;

package/dist/test/approver-wiring.test.js

@@ -0,0 +1,111 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { newPairing, deriveKey, seal, open, aadForRequest, aadForDecision } from "../pwacrypto.js";
+import { startRelay } from "../relay/server.js";
+import { pwaApproverFrom } from "../pwa-approver.js";
+import { DEFAULT_CONFIG } from "../config.js";
+/**
+ * Guards the wiring, not the crypto: enforcement must reach the phone
+ * from every entry point. `sandgate test-approval` once built its own
+ * approver config and quietly dropped requireBiometric, so an enforced
+ * vault still accepted a bare tap. One builder now serves serve() and the
+ * CLI, and this test fails if it ever stops enforcing.
+ */
+const CREDENTIAL = {
+    credentialId: "unused-for-this-test",
+    publicKeySpki: "unused-for-this-test",
+    rpId: "localhost",
+    origin: "http://localhost",
+    enrolledAt: new Date().toISOString(),
+};
+/** A phone that taps Approve without producing any assertion. */
+async function tapWithoutAssertion(relayUrl, pairId, secret) {
+    const key = deriveKey(secret);
+    for (let i = 0; i < 100; i++) {
+        const res = await fetch(`${relayUrl}/api/pending?pairId=${pairId}`);
+        const items = (await res.json());
+        if (items.length) {
+            const { requestId, payload } = items[0];
+            const request = open(key, payload, aadForRequest(requestId));
+            await fetch(`${relayUrl}/api/decision`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    pairId,
+                    requestId,
+                    payload: seal(key, { requestId, approved: true, ts: Date.now() }, aadForDecision(requestId)),
+                }),
+            });
+            return request;
+        }
+        await new Promise((r) => setTimeout(r, 50));
+    }
+    throw new Error("phone never saw a request");
+}
+/** Settle a promise without ever leaving a rejection unhandled. */
+function settled(p) {
+    return p.then((value) => ({ value }), (error) => ({ error }));
+}
+async function withRelay(fn) {
+    const relay = await startRelay({
+        port: 0,
+        stateDir: mkdtempSync(join(tmpdir(), "sandgate-relay-")),
+    });
+    try {
+        return await fn(`http://localhost:${relay.port}`);
+    }
+    finally {
+        relay.close();
+    }
+}
+test("an enforced vault rejects an approval that carries no assertion", async () => {
+    await withRelay(async (relayUrl) => {
+        const pairing = newPairing();
+        const vault = {
+            totp: {},
+            pwa: { relayUrl, pairId: pairing.pairId, secret: pairing.secret },
+            biometric: CREDENTIAL,
+        };
+        const approver = pwaApproverFrom(vault, { ...DEFAULT_CONFIG, requireBiometric: true });
+        const deciding = settled(approver.request({ title: "Pay 300 EUR", timeoutSec: 15 }));
+        const request = await tapWithoutAssertion(relayUrl, pairing.pairId, pairing.secret);
+        // The phone must be TOLD to ask for biometrics...
+        assert.equal(request.requireBiometric, true, "the request did not demand a biometric");
+        // ...and a bare tap must not pass for an approval.
+        const outcome = await deciding;
+        assert.equal(outcome.value, undefined, "a bare tap was accepted as an approval");
+        assert.match(String(outcome.error), /without the required biometric assertion/);
+    });
+});
+test("without enforcement, the same tap is a normal approval", async () => {
+    await withRelay(async (relayUrl) => {
+        const pairing = newPairing();
+        const vault = {
+            totp: {},
+            pwa: { relayUrl, pairId: pairing.pairId, secret: pairing.secret },
+        };
+        const approver = pwaApproverFrom(vault, { ...DEFAULT_CONFIG, requireBiometric: false });
+        const deciding = settled(approver.request({ title: "Harmless", timeoutSec: 15 }));
+        const request = await tapWithoutAssertion(relayUrl, pairing.pairId, pairing.secret);
+        assert.equal(request.requireBiometric, false);
+        assert.deepEqual((await deciding).value, { approved: true, decision: "approved" });
+    });
+});
+test("enforcement without an enrolled credential refuses instead of downgrading", async () => {
+    await withRelay(async (relayUrl) => {
+        const pairing = newPairing();
+        const vault = {
+            totp: {},
+            pwa: { relayUrl, pairId: pairing.pairId, secret: pairing.secret },
+        };
+        const approver = pwaApproverFrom(vault, { ...DEFAULT_CONFIG, requireBiometric: true });
+        const deciding = settled(approver.request({ title: "Pay 300 EUR", timeoutSec: 15 }));
+        await tapWithoutAssertion(relayUrl, pairing.pairId, pairing.secret);
+        const outcome = await deciding;
+        assert.equal(outcome.value, undefined, "an unenrolled vault approved anyway");
+        assert.match(String(outcome.error), /no credential is enrolled/);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sandprivacy/sandgate",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "The human gateway for AI agents — approvals, 2FA codes and email verification, self-hosted. Your agent asks; you decide; secrets never touch the LLM.",
   "license": "AGPL-3.0-only",
   "type": "module",