test: page-side body-hash + content-script message whitelist

jjohare · jjohare · commit 56fc537c5d4b · 2026-06-14T20:25:36.000Z
body-hash.test.js (11): exercise the real bodyToHashHex inside the
nip98-interceptor IIFE by running it in a vm sandbox with a minimal page
(window/fetch/XHR) and capturing the bodyHash it emits on podkey-nip98-request.
Correct sha-256 hex for string, URLSearchParams, Blob, ArrayBuffer and
typed-array bodies (respecting view offset); "" for no/empty body; "" for
FormData (no canonical NIP-98 multipart hash). A page-set Authorization
suppresses NIP-98 injection; absent auth emits a request.

content-whitelist.test.js (9): injected.js forwards only the four NIP-07 types,
rejects anything else (incl. CREATE_NIP98_AUTH_HEADER, which has its own
channel) with "Unknown request type" and never calls sendMessage for it;
forwards only safe fields per type, always overriding origin with the real page
origin (drops attacker-supplied privateKey/peer/extra) and coerces nip44 fields
to strings.

Co-Authored-By: jjohare &lt;github@thedreamlab.uk&gt;
diff --git a/test/body-hash.test.js b/test/body-hash.test.js
@@ -0,0 +1,152 @@
+/**
+ * Tests for bodyToHashHex — the page-side NIP-98 `payload` body hashing in
+ * nip98-interceptor.js. The raw request body never crosses to the background
+ * service worker; the page computes its SHA-256 here (the only context where
+ * FormData / URLSearchParams / Blob survive intact) and ships only the digest.
+ *
+ * bodyToHashHex is a private function inside the interceptor's page-context
+ * IIFE (no ESM export — classic scripts can't import). To exercise the real
+ * source it is loaded and run inside a vm sandbox with a minimal page (window,
+ * fetch, XHR), and the bodyHash the interceptor emits on the
+ * podkey-nip98-request event is captured. This drives the genuine code path
+ * (window.fetch wrapper -> getNip98AuthHeader -> bodyToHashHex) rather than a
+ * reimplementation.
+ */
+
+import { describe, it, before } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { createHash, webcrypto } from 'node:crypto';
+import vm from 'node:vm';
+
+const sha256hex = (input) => createHash('sha256').update(input).digest('hex');
+
+/** Build a fresh sandboxed page with the interceptor installed. */
+function makeInterceptedPage () {
+  const src = readFileSync(new URL('../src/nip98-interceptor.js', import.meta.url), 'utf8');
+  const bus = new EventTarget();
+  const win = {
+    __podkey_nip98_intercepted: false,
+    addEventListener: (...a) => bus.addEventListener(...a),
+    removeEventListener: (...a) => bus.removeEventListener(...a),
+    dispatchEvent: (e) => bus.dispatchEvent(e),
+    // originalFetch: a stub the wrapper calls after deciding on auth.
+    fetch: async () => ({ status: 200, redirected: false, url: '' })
+  };
+
+  // Echo every nip98 request back immediately so the fetch wrapper resolves,
+  // recording the detail (which carries bodyHash) for assertions.
+  const requests = [];
+  bus.addEventListener('podkey-nip98-request', (e) => {
+    requests.push(e.detail);
+    bus.dispatchEvent(new CustomEvent('podkey-nip98-response', { detail: { id: e.detail.id, result: null } }));
+  });
+
+  // Minimal XHR so the interceptor can patch its prototype without throwing.
+  function XHR () {}
+  XHR.prototype = { open () {}, send () {}, setRequestHeader () {} };
+
+  const sandbox = {
+    window: win,
+    XMLHttpRequest: XHR,
+    crypto: webcrypto,
+    CustomEvent, Headers, Request, TextEncoder,
+    Blob, URLSearchParams, ArrayBuffer, Uint8Array, Uint16Array, Array, Object,
+    console, setTimeout, clearTimeout
+  };
+  vm.createContext(sandbox);
+  vm.runInContext(src, sandbox);
+
+  return {
+    /** Issue a fetch through the wrapped fetch and return the captured bodyHash. */
+    async fetchAndGetHash (init) {
+      requests.length = 0;
+      await win.fetch('https://pod.test/r', init);
+      assert.equal(requests.length, 1, 'interceptor should emit exactly one nip98 request');
+      return requests[0].bodyHash;
+    },
+    /** Issue a fetch and return whether any nip98 request was emitted. */
+    async fetchEmitsRequest (input, init) {
+      requests.length = 0;
+      await win.fetch(input, init);
+      return requests.length > 0;
+    }
+  };
+}
+
+describe('bodyToHashHex (NIP-98 page-side body hashing)', () => {
+  let page;
+  before(() => { page = makeInterceptedPage(); });
+
+  it('hashes a string body to its sha-256 hex', async () => {
+    const body = '{"hello":"world"}';
+    assert.equal(await page.fetchAndGetHash({ method: 'POST', body }), sha256hex(body));
+  });
+
+  it('hashes a URLSearchParams body via its serialized form', async () => {
+    const params = new URLSearchParams({ a: '1', b: 'two' });
+    assert.equal(await page.fetchAndGetHash({ method: 'POST', body: params }), sha256hex(params.toString()));
+  });
+
+  it('hashes a Blob body by its bytes', async () => {
+    const text = 'blob-bytes-😀';
+    const blob = new Blob([text]);
+    const expected = sha256hex(Buffer.from(text, 'utf8'));
+    assert.equal(await page.fetchAndGetHash({ method: 'PUT', body: blob }), expected);
+  });
+
+  it('hashes an ArrayBuffer body', async () => {
+    const bytes = new Uint8Array([1, 2, 3, 4, 250, 255]);
+    const expected = sha256hex(Buffer.from(bytes));
+    assert.equal(await page.fetchAndGetHash({ method: 'POST', body: bytes.buffer }), expected);
+  });
+
+  it('hashes a typed-array (Uint8Array) body', async () => {
+    const bytes = new Uint8Array([10, 20, 30]);
+    const expected = sha256hex(Buffer.from(bytes));
+    assert.equal(await page.fetchAndGetHash({ method: 'POST', body: bytes }), expected);
+  });
+
+  it('respects a typed-array view offset (does not hash the whole buffer)', async () => {
+    const full = new Uint8Array([0, 0, 1, 2, 3, 0]);
+    const view = full.subarray(2, 5); // [1,2,3]
+    const expected = sha256hex(Buffer.from([1, 2, 3]));
+    assert.equal(await page.fetchAndGetHash({ method: 'POST', body: view }), expected);
+  });
+
+  it('returns "" for no body (GET)', async () => {
+    assert.equal(await page.fetchAndGetHash({ method: 'GET' }), '');
+  });
+
+  it('returns "" for an empty-string body', async () => {
+    assert.equal(await page.fetchAndGetHash({ method: 'POST', body: '' }), '');
+  });
+
+  it('returns "" for a FormData body (no canonical NIP-98 multipart hash)', async () => {
+    // Documented decision: NIP-98 defines no canonical hash for multipart bodies,
+    // so FormData is intentionally not hashed (no payload tag is added). A
+    // FormData instance matches none of bodyToHashHex's recognised body types
+    // (string / URLSearchParams / Blob / ArrayBuffer / typed-array) and hits the
+    // `return ''` fallthrough.
+    const fd = new FormData();
+    fd.append('field', 'value');
+    assert.equal(await page.fetchAndGetHash({ method: 'POST', body: fd }), '');
+  });
+});
+
+describe('interceptor honors a page-set Authorization (no NIP-98 injection)', () => {
+  let page;
+  before(() => { page = makeInterceptedPage(); });
+
+  it('does not emit a nip98 request when init.headers already has Authorization', async () => {
+    const emitted = await page.fetchEmitsRequest('https://pod.test/r', {
+      method: 'GET', headers: { Authorization: 'DPoP page-token' }
+    });
+    assert.equal(emitted, false, 'page-set DPoP must not be overwritten by NIP-98');
+  });
+
+  it('emits a nip98 request when no Authorization is present', async () => {
+    const emitted = await page.fetchEmitsRequest('https://pod.test/r', { method: 'GET' });
+    assert.equal(emitted, true);
+  });
+});
diff --git a/test/content-whitelist.test.js b/test/content-whitelist.test.js
@@ -0,0 +1,142 @@
+/**
+ * Tests for the content-script message-type whitelist (injected.js,
+ * security/whitelist-message-types #19).
+ *
+ * The content script bridges page CustomEvents to chrome.runtime. It must:
+ *   - forward ONLY the four NIP-07 message types, rejecting anything else with
+ *     "Unknown request type" and never calling sendMessage for it
+ *   - forward ONLY known-safe fields per type (no arbitrary page-supplied props
+ *     reach the background), always appending the real page origin
+ *
+ * injected.js runs at import time against the DOM and chrome.runtime, so the
+ * test mounts minimal window/document/chrome and then drives it via the
+ * podkey-request / podkey-response CustomEvents the provider uses.
+ */
+
+import { describe, it, before, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+
+const ORIGIN = 'https://app.test';
+const bus = new EventTarget();
+const forwarded = [];
+
+before(async () => {
+  global.window = {
+    addEventListener: (...a) => bus.addEventListener(...a),
+    removeEventListener: (...a) => bus.removeEventListener(...a),
+    dispatchEvent: (e) => bus.dispatchEvent(e),
+    location: { origin: ORIGIN }
+  };
+  global.document = {
+    createElement: () => ({ set src (_v) {}, set onload (_v) {}, set onerror (_v) {}, remove () {} }),
+    head: { appendChild () {} },
+    documentElement: { appendChild () {} }
+  };
+  global.chrome = {
+    runtime: {
+      getURL: (p) => 'chrome-extension://test/' + p,
+      sendMessage: async (message) => {
+        forwarded.push(message);
+        if (message.type === 'GET_PUBLIC_KEY') return 'a'.repeat(64);
+        if (message.type === 'SIGN_EVENT') return { ...message.event, id: 'i'.repeat(64), sig: 's'.repeat(128) };
+        return 'OK';
+      },
+      lastError: null
+    }
+  };
+  await import('../src/injected.js');
+});
+
+beforeEach(() => { forwarded.length = 0; });
+
+let seq = 0;
+/** Dispatch a podkey-request and resolve with the matching podkey-response. */
+function request (detail) {
+  const id = `req-${++seq}`;
+  return new Promise((resolve) => {
+    const handler = (e) => {
+      if (e.detail.id !== id) return;
+      bus.removeEventListener('podkey-response', handler);
+      resolve(e.detail);
+    };
+    bus.addEventListener('podkey-response', handler);
+    bus.dispatchEvent(new CustomEvent('podkey-request', { detail: { id, ...detail } }));
+  });
+}
+
+describe('content-script whitelist', () => {
+  it('forwards GET_PUBLIC_KEY and returns the result', async () => {
+    const res = await request({ type: 'GET_PUBLIC_KEY' });
+    assert.equal(res.result, 'a'.repeat(64));
+    assert.equal(forwarded.length, 1);
+    assert.equal(forwarded[0].type, 'GET_PUBLIC_KEY');
+  });
+
+  it('forwards SIGN_EVENT, NIP44_ENCRYPT and NIP44_DECRYPT', async () => {
+    await request({ type: 'SIGN_EVENT', event: { kind: 1, created_at: 1, tags: [], content: 'x' } });
+    await request({ type: 'NIP44_ENCRYPT', pubkey: 'f'.repeat(64), plaintext: 'hi' });
+    await request({ type: 'NIP44_DECRYPT', pubkey: 'f'.repeat(64), ciphertext: 'BASE64' });
+    assert.deepEqual(forwarded.map((m) => m.type), ['SIGN_EVENT', 'NIP44_ENCRYPT', 'NIP44_DECRYPT']);
+  });
+
+  it('rejects an unknown type and never forwards it', async () => {
+    const res = await request({ type: 'EXPORT_PRIVATE_KEY' });
+    assert.deepEqual(res, { id: res.id, error: 'Unknown request type' });
+    assert.equal(forwarded.length, 0, 'an unknown type must not reach the background');
+  });
+
+  it('rejects NIP-98 header type on the NIP-07 channel (separate channel only)', async () => {
+    // CREATE_NIP98_AUTH_HEADER is intentionally not in the NIP-07 whitelist;
+    // it has its own podkey-nip98-request channel.
+    const res = await request({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://x/', method: 'GET' });
+    assert.equal(res.error, 'Unknown request type');
+    assert.equal(forwarded.length, 0);
+  });
+
+  it('always appends the page origin to forwarded messages', async () => {
+    await request({ type: 'GET_PUBLIC_KEY' });
+    assert.equal(forwarded[0].origin, ORIGIN);
+  });
+});
+
+describe('content-script field stripping (only safe fields forwarded)', () => {
+  it('SIGN_EVENT forwards only { event, type, origin } — drops injected extras', async () => {
+    await request({
+      type: 'SIGN_EVENT',
+      event: { kind: 1, created_at: 1, tags: [], content: 'x' },
+      privateKey: 'attacker-supplied', // must NOT be forwarded
+      origin: 'https://spoofed.evil' // page-supplied origin must be overridden
+    });
+    const msg = forwarded[0];
+    assert.deepEqual(Object.keys(msg).sort(), ['event', 'origin', 'type']);
+    assert.equal(msg.origin, ORIGIN, 'origin must be the real page origin, not a spoofed one');
+    assert.equal('privateKey' in msg, false);
+  });
+
+  it('NIP44_ENCRYPT forwards only pubkey + plaintext (field is "pubkey", not "peer")', async () => {
+    await request({
+      type: 'NIP44_ENCRYPT', pubkey: 'f'.repeat(64), plaintext: 'secret',
+      peer: 'should-be-dropped', extra: 'nope'
+    });
+    const msg = forwarded[0];
+    assert.deepEqual(Object.keys(msg).sort(), ['origin', 'plaintext', 'pubkey', 'type']);
+    assert.equal(msg.pubkey, 'f'.repeat(64));
+    assert.equal(msg.plaintext, 'secret');
+    assert.equal('peer' in msg, false);
+    assert.equal('extra' in msg, false);
+  });
+
+  it('NIP44_DECRYPT forwards only pubkey + ciphertext', async () => {
+    await request({ type: 'NIP44_DECRYPT', pubkey: 'f'.repeat(64), ciphertext: 'BASE64', junk: 1 });
+    const msg = forwarded[0];
+    assert.deepEqual(Object.keys(msg).sort(), ['ciphertext', 'origin', 'pubkey', 'type']);
+    assert.equal('junk' in msg, false);
+  });
+
+  it('coerces NIP44 fields to strings', async () => {
+    await request({ type: 'NIP44_ENCRYPT', pubkey: 123, plaintext: 456 });
+    const msg = forwarded[0];
+    assert.equal(typeof msg.pubkey, 'string');
+    assert.equal(typeof msg.plaintext, 'string');
+  });
+});
