app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

commit 90762e7b75cff35a72ece3dc3c922b3e3421101c
parent 2904a994d5ba6199c444586089720244c8d1eed8
Author: triesap <tyson@radroots.org>
Date:   Fri,  9 Oct 2026 05:22:03 +0000

messages: validate nested received seals and rumor identity (HCP-091)

Diffstat:
Aweb/src/lib/nostr/unwrap-admission.ts | 469+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/conformance/received-envelopes.test.ts | 231+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/harness/received-envelopes.ts | 149+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/received-envelopes.spec.ts | 240+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
4 files changed, 1089 insertions(+), 0 deletions(-)

diff --git a/web/src/lib/nostr/unwrap-admission.ts b/web/src/lib/nostr/unwrap-admission.ts @@ -0,0 +1,469 @@ +import { ExtensionSigner } from 'applesauce-signers'; +import { getEventHash, type UnsignedEvent } from 'applesauce-core/helpers'; +import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts'; +import { canonicalPublicKey } from '../contracts/public-key.ts'; +import { exactLocalFields } from '../contracts/local-records.ts'; +import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts'; +import { + messageFromWireParts, + messageToWireParts +} from '../contracts/message-v1/index.ts'; +import { + identityMessagingOwnership, + subscribeIdentityInvalidation, + disconnectIdentity, + type IdentitySession +} from '../runtime/identity-session.ts'; +import { + loadPrivateRecord, + type PrivateStorageRepository, + type PrivateStorageFailure +} from '../persistence/private-storage.ts'; +import { + privateRecordSnapshot, + privateRecordWire +} from '../persistence/private-records.ts'; +import { safeUnsignedInteger } from './envelope-bounds.ts'; +import { + verifyEnvelope, + verifiedEnvelopeSnapshot +} from './verified-envelope.ts'; +import { sealCiphertextV2 } from './seal-template.ts'; +import { + browserExtensionScheduler, + runExtensionAction, + callExtension, + stopExtensionAction, + markExtensionWaitExpired, + type ExtensionAction +} from './extension-scheduler.ts'; + +const unsignedFields = [ + 'id', + 'pubkey', + 'created_at', + 'kind', + 'tags', + 'content' +]; +const signedFields = [...unsignedFields, 'sig']; +// Syntax-only duplicate detection precedes ordinary JSON semantics. Escaped +// field aliases count as the same key; harmless whitespace stays supported. +function uniqueJSONFields(raw: string): boolean { + type Frame = { + array: boolean; + key: boolean; + parent: Frame | undefined; + accept: (name: string) => boolean; + }; + function frame(parent: Frame | undefined, array: boolean): Frame { + const names = new Set<string>(); + return { + parent, + array, + key: !array, + accept: (name: string) => { + if (names.has(name)) return false; + names.add(name); + return true; + } + }; + } + let current: Frame | undefined; + try { + for (let index = 0; index < raw.length; index++) { + const character = raw[index]; + if (character === '"') { + let end = index + 1; + while (end < raw.length) { + if (raw[end] === '\\') { + end += 2; + continue; + } + if (raw[end] === '"') break; + end++; + } + if (end >= raw.length) return false; + if (current && !current.array && current.key) { + const name: unknown = JSON.parse(raw.slice(index, end + 1)); + if (typeof name !== 'string' || !current.accept(name)) return false; + current = { + parent: current.parent, + array: current.array, + accept: current.accept, + key: false + }; + } + index = end; + } else if (character === '{' || character === '[') + current = frame(current, character === '['); + else if (character === '}' || character === ']') { + if (!current) return false; + current = current.parent; + } else if (character === ',' && current && !current.array) + current = { + parent: current.parent, + array: current.array, + accept: current.accept, + key: true + }; + } + return current === undefined; + } catch { + return false; + } +} +function layer(raw: unknown, bytes: number): unknown { + if ( + typeof raw !== 'string' || + !boundedUtf8(raw, bytes) || + !uniqueJSONFields(raw) + ) + return undefined; + try { + let invalid = false; + const parsed: unknown = JSON.parse( + raw, + function (key: string, value: unknown, context?: { source?: string }) { + if ( + !key.isWellFormed() || + (typeof value === 'string' && !value.isWellFormed()) + ) + invalid = true; + if ( + typeof value === 'number' && + (!Number.isFinite(value) || + ((key === 'kind' || key === 'created_at') && + (context?.source === undefined || + !/^[0-9]+$/u.test(context.source)))) + ) + invalid = true; + return value; + } + ); + return invalid ? undefined : parsed; + } catch { + return undefined; + } +} +function outerLayer(raw: unknown, owner: string) { + const parsed = layer(raw, PRIVATE_TRANSPORT_BUDGETS.envelopeBytes); + if ( + !exactLocalFields(parsed, signedFields) || + parsed.kind !== 1059 || + JSON.stringify(parsed.tags) !== JSON.stringify([['p', owner]]) || + !sealCiphertextV2(parsed.content) + ) + return undefined; + const verified = verifyEnvelope(raw); + return verified.ok ? verifiedEnvelopeSnapshot(verified.value) : undefined; +} +function sealLayer(raw: unknown) { + const parsed = layer(raw, PRIVATE_TRANSPORT_BUDGETS.sealBytes); + if ( + !exactLocalFields(parsed, signedFields) || + parsed.kind !== 13 || + !Array.isArray(parsed.tags) || + parsed.tags.length !== 0 || + !sealCiphertextV2(parsed.content) + ) + return undefined; + const verified = verifyEnvelope(raw); + return verified.ok ? verifiedEnvelopeSnapshot(verified.value) : undefined; +} +function rumorLayer( + raw: unknown, + sender: string +): Readonly<UnsignedEvent & { id: string }> | undefined { + const parsed = layer(raw, PRIVATE_TRANSPORT_BUDGETS.rumorBytes); + if ( + !exactLocalFields(parsed, unsignedFields) || + parsed.kind !== 14 || + parsed.pubkey !== sender || + canonicalPublicKey(parsed.pubkey) !== sender || + safeUnsignedInteger(parsed.created_at) === undefined || + typeof parsed.id !== 'string' || + !/^[0-9a-f]{64}$/u.test(parsed.id) + ) + return undefined; + const parts = { kind: 14, tags: parsed.tags, content: parsed.content }; + const decoded = messageFromWireParts(JSON.stringify(parts)); + if ( + !decoded || + decoded.recipients.length !== 1 || + decoded.recipients[0].public_key === sender + ) + return undefined; + const canonical = messageToWireParts(JSON.stringify(decoded)); + if (!canonical || JSON.stringify(canonical) !== JSON.stringify(parts)) + return undefined; + const template: UnsignedEvent = { + pubkey: sender, + kind: 14, + created_at: parsed.created_at as number, + tags: canonical.tags.map((row) => [...row]), + content: canonical.content + }; + return getEventHash(template) === parsed.id + ? { id: parsed.id, ...template } + : undefined; +} +// Detached inspection only: supplied plaintext cannot prove ciphertext +// correspondence. Only the scoped actual SDK issuer below mints nested custody. +// Owner room membership and inbound/archive role are a separate admission. +export function verifyReceivedLayerData( + outerRaw: unknown, + sealRaw: unknown, + rumorRaw: unknown, + expectedOwner: unknown +): boolean { + const owner = canonicalPublicKey(expectedOwner); + if (!owner) return false; + try { + const outer = outerLayer(outerRaw, owner), + seal = sealLayer(sealRaw); + return !!outer && !!seal && !!rumorLayer(rumorRaw, seal.pubkey); + } catch { + return false; + } +} + +declare const readerBrand: unique symbol; +declare const nestedBrand: unique symbol; +export type ReceivedUnwrap = Readonly<{ [readerBrand]: true }>; +export type ReceivedNestedEnvelope = Readonly<{ [nestedBrand]: true }>; +type Snapshot = Readonly<{ + owner: string; + outerId: string; + outerWire: string; + sealWire: string; + rumorWire: string; +}>; +export type ReceivedUnwrapResult = + | Readonly<{ status: 'authenticated'; envelope: ReceivedNestedEnvelope }> + | Readonly<{ + status: + | PrivateStorageFailure + | 'invalid' + | 'stopped' + | 'busy' + | 'refused' + | 'mismatch' + | 'lost_evidence'; + }>; +type Reader = { + run(): Promise<ReceivedUnwrapResult>; + stop(expired: boolean): void; +}; +const readers = new WeakMap<ReceivedUnwrap, Reader>(); +const nested = new WeakMap< + ReceivedNestedEnvelope, + { snapshot: Snapshot; current(): boolean } +>(); +// No common unwrap helper/cache or caller event objects are consulted. Original +// owner storage finishes each IDB transaction before serialized SDK work begins. +export function captureReceivedUnwrap( + repository: PrivateStorageRepository, + session: IdentitySession, + eventId: unknown, + review: unknown +): ReceivedUnwrap | undefined { + if ( + typeof window === 'undefined' || + review !== 'reviewed_inbox_unlock' || + typeof eventId !== 'string' || + !/^[0-9a-f]{64}$/u.test(eventId) + ) + return undefined; + const captured = identityMessagingOwnership(session); + if (!captured?.current()) return undefined; + const ownership = captured, + id = eventId; + let stopped = false, + started = false, + active: ExtensionAction | undefined, + proof: ReceivedNestedEnvelope | undefined, + unsubscribe = () => {}; + const current = () => !stopped && ownership.current(); + function stop(expired: boolean) { + stopped = true; + if (active) { + if (expired) markExtensionWaitExpired(active); + else stopExtensionAction(active); + } + if (proof) nested.delete(proof); + proof = undefined; + unsubscribe(); + unsubscribe = () => {}; + } + function port() { + try { + if (!current()) return undefined; + const cipher = new ExtensionSigner().nip44; + if (!cipher || !current() || typeof cipher.decrypt !== 'function') + return undefined; + const decrypt = cipher.decrypt.bind(cipher); + return current() ? { decrypt } : undefined; + } catch { + return undefined; + } + } + async function fresh(action: ExtensionAction) { + if (!current()) return false; + const result = await callExtension(action, 'key', () => + new ExtensionSigner().getPublicKey() + ); + if (!current()) return false; + if ( + result.status !== 'settled' || + !result.current || + result.value !== ownership.owner || + !port() + ) { + disconnectIdentity(session); + return false; + } + return current(); + } + async function run(): Promise<ReceivedUnwrapResult> { + if (started || !current()) return { status: 'stopped' }; + started = true; + try { + const loaded = await loadPrivateRecord( + repository, + 'received_envelopes', + id + ); + if (!current()) return { status: 'stopped' }; + if (!loaded.ok) + return { + status: + loaded.reason === 'invalid_record' ? 'lost_evidence' : loaded.reason + }; + const record = privateRecordSnapshot(loaded.value, ownership.owner, id), + storedWire = privateRecordWire(loaded.value, ownership.owner, id); + if (!record || record.family !== 'received_envelope' || !storedWire) + return { status: 'invalid_scope' }; + const outer = outerLayer(record.outer, ownership.owner); + if (!outer || outer.id !== id) return { status: 'mismatch' }; + const scheduler = browserExtensionScheduler(); + if (!scheduler) return { status: 'unavailable' }; + const result = await runExtensionAction( + scheduler, + { + owner: ownership.owner, + session: ownership.session, + operation: Symbol() + }, + current, + async (action): Promise<ReceivedUnwrapResult> => { + active = action; + if (!(await fresh(action))) return { status: 'stopped' }; + const outerPort = port(); + if (!outerPort || !current()) return { status: 'stopped' }; + const opened = await callExtension(action, 'decrypt', () => + outerPort.decrypt(outer.pubkey, outer.content) + ); + if (!current()) return { status: 'stopped' }; + if (opened.status !== 'settled' || !opened.current) + return { + status: opened.status === 'denied' ? 'refused' : 'stopped' + }; + const seal = sealLayer(opened.value); + if (!seal || typeof opened.value !== 'string') + return { status: 'mismatch' }; + const sealWire = opened.value; + if (!(await fresh(action))) return { status: 'stopped' }; + const innerPort = port(); + if (!innerPort || !current()) return { status: 'stopped' }; + const decrypted = await callExtension(action, 'decrypt', () => + innerPort.decrypt(seal.pubkey, seal.content) + ); + if (!current()) return { status: 'stopped' }; + if (decrypted.status !== 'settled' || !decrypted.current) + return { + status: decrypted.status === 'denied' ? 'refused' : 'stopped' + }; + if ( + typeof decrypted.value !== 'string' || + !rumorLayer(decrypted.value, seal.pubkey) + ) + return { status: 'mismatch' }; + const rumorWire = decrypted.value; + if (!(await fresh(action))) return { status: 'stopped' }; + const readback = await loadPrivateRecord( + repository, + 'received_envelopes', + id + ); + if (!current()) return { status: 'stopped' }; + if (!readback.ok) + return { + status: + readback.reason === 'invalid_record' + ? 'lost_evidence' + : readback.reason + }; + if ( + privateRecordWire(readback.value, ownership.owner, id) !== + storedWire + ) + return { status: 'conflict' }; + // Last actual storage readback is followed by no SDK/asynchronous + // wait before minting original retained-record custody. + const token = Object.freeze({}) as ReceivedNestedEnvelope; + nested.set(token, { + snapshot: { + owner: ownership.owner, + outerId: id, + outerWire: record.outer, + sealWire, + rumorWire + }, + current + }); + proof = token; + return { status: 'authenticated', envelope: token }; + } + ); + if (!current()) return { status: 'stopped' }; + if (result.status === 'busy') return { status: 'busy' }; + return result.status === 'completed' && 'value' in result && result.value + ? result.value + : { status: result.status === 'denied' ? 'refused' : 'stopped' }; + } catch { + return { status: current() ? 'mismatch' : 'stopped' }; + } finally { + active = undefined; + if (!proof) { + unsubscribe(); + unsubscribe = () => {}; + } + } + } + const token = Object.freeze({}) as ReceivedUnwrap; + readers.set(token, { run, stop }); + unsubscribe = subscribeIdentityInvalidation(session, () => { + if (!ownership.current()) stop(false); + }); + return current() ? token : undefined; +} +export function unwrapReceivedEnvelope( + reader: ReceivedUnwrap +): Promise<ReceivedUnwrapResult> { + return readers.get(reader)?.run() ?? Promise.resolve({ status: 'invalid' }); +} +export function stopReceivedUnwrap(reader: ReceivedUnwrap): void { + readers.get(reader)?.stop(false); +} +export function expireReceivedUnwrapWait(reader: ReceivedUnwrap): void { + readers.get(reader)?.stop(true); +} +export function receivedNestedEnvelopeSnapshot( + token: ReceivedNestedEnvelope +): Snapshot | undefined { + const saved = nested.get(token); + return saved?.current() + ? (JSON.parse(JSON.stringify(saved.snapshot)) as Snapshot) + : undefined; +} diff --git a/web/tests/conformance/received-envelopes.test.ts b/web/tests/conformance/received-envelopes.test.ts @@ -0,0 +1,231 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { + generateSecretKey, + getPublicKey, + getEventHash, + finalizeEvent, + type UnsignedEvent +} from 'applesauce-core/helpers'; +import { nip44 } from 'applesauce-core/helpers/encryption'; +import { verifyReceivedLayerData } from '../../src/lib/nostr/unwrap-admission.ts'; +function fixture() { + const keys = [generateSecretKey(), generateSecretKey(), generateSecretKey()], + sender = getPublicKey(keys[0]), + owner = getPublicKey(keys[1]); + const template: UnsignedEvent = { + pubkey: sender, + kind: 14, + created_at: 1700000000, + tags: [['p', owner]], + content: 'Bounded inbound enquiry' + }; + const rumor = { id: getEventHash(template), ...template }; + const conversation = nip44.v2.utils.getConversationKey(keys[0], owner); + let content: string; + try { + content = nip44.v2.encrypt(JSON.stringify(rumor), conversation); + } finally { + conversation.fill(0); + } + const seal = finalizeEvent( + { kind: 13, created_at: 1699999900, tags: [], content }, + keys[0] + ); + const wrapConversation = nip44.v2.utils.getConversationKey(keys[2], owner); + let outerContent: string; + try { + outerContent = nip44.v2.encrypt(JSON.stringify(seal), wrapConversation); + } finally { + wrapConversation.fill(0); + } + const outer = finalizeEvent( + { + kind: 1059, + created_at: 1699999800, + tags: [['p', owner]], + content: outerContent + }, + keys[2] + ); + const check = (r: unknown = rumor, s: unknown = seal, o: unknown = outer) => + verifyReceivedLayerData( + JSON.stringify(o), + JSON.stringify(s), + JSON.stringify(r), + owner + ); + return { + keys, + sender, + owner, + rumor, + seal, + outer, + check, + close() { + keys.forEach((k) => k.fill(0)); + } + }; +} +async function vector( + name: string, + run: (f: ReturnType<typeof fixture>) => void +) { + await test(name, () => { + const f = fixture(); + try { + run(f); + } finally { + f.close(); + } + }); +} +await vector( + 'actual signed layers and freshly hashed unsigned pair rumor pass detached inspection', + (f) => assert.equal(f.check(), true) +); +await vector( + 'forged inner author fails even after recomputing rumor hash', + (f) => { + const r = { ...f.rumor, pubkey: f.owner }; + r.id = getEventHash(r); + assert.equal(f.check(r), false); + } +); +await vector('forged seal signature fails before nested rumor admission', (f) => + assert.equal(f.check(f.rumor, { ...f.seal, sig: '0'.repeat(128) }), false) +); +await vector( + 'a valid differently signed seal cannot authenticate original rumor author', + (f) => + assert.equal( + f.check(f.rumor, finalizeEvent({ ...f.seal }, f.keys[1])), + false + ) +); +await vector('supplied rumor id is never a cache identity substitute', (f) => + assert.equal(f.check({ ...f.rumor, id: '0'.repeat(64) }), false) +); +await vector( + 'signed rumor is unsupported rather than silently accepted as unsigned14', + (f) => assert.equal(f.check(finalizeEvent({ ...f.rumor }, f.keys[0])), false) +); +await vector('wrong kind and file metadata are isolated', (f) => { + const r = { + ...f.rumor, + kind: 15, + tags: [...f.rumor.tags, ['file', 'https://example.org/a']] + }; + r.id = getEventHash(r); + assert.equal(f.check(r), false); +}); +await vector('group fanout cannot become an admitted pair rumor', (f) => { + const r = { + ...f.rumor, + tags: [...f.rumor.tags, ['p', getPublicKey(f.keys[2])]] + }; + r.id = getEventHash(r); + assert.equal(f.check(r), false); +}); +await vector('self-only participants are unsupported', (f) => { + const r = { ...f.rumor, tags: [['p', f.sender]] }; + r.id = getEventHash(r); + assert.equal(f.check(r), false); +}); +await vector('nonempty seal tags are rejected despite a valid signature', (f) => + assert.equal( + f.check( + f.rumor, + finalizeEvent({ ...f.seal, tags: [['client', 'unsupported']] }, f.keys[0]) + ), + false + ) +); +await vector( + 'wrong outer destination cannot cross owner-scoped admission', + (f) => + assert.equal( + f.check( + f.rumor, + f.seal, + finalizeEvent({ ...f.outer, tags: [['p', f.sender]] }, f.keys[2]) + ), + false + ) +); +await vector('body and layer bounds are checked without truncation', (f) => { + const r = { ...f.rumor, content: 'x'.repeat(4097) }; + r.id = getEventHash(r); + assert.equal(f.check(r), false); + assert.equal( + verifyReceivedLayerData( + JSON.stringify(f.outer), + JSON.stringify(f.seal), + 'x'.repeat(8193), + f.owner + ), + false + ); +}); +await vector( + 'caller objects and imported or persisted verification markers cannot bypass fresh parsing', + (f) => { + let calls = 0; + const value = { + ...f.rumor, + toJSON() { + calls++; + return f.rumor; + } + }; + assert.equal( + verifyReceivedLayerData( + JSON.stringify(f.outer), + JSON.stringify(f.seal), + value, + f.owner + ), + false + ); + assert.equal(calls, 0); + assert.equal(f.check({ ...f.rumor, verified: true }), false); + } +); +await vector( + 'harmless JSON whitespace works while duplicate fields and noncanonical numeric lexemes fail', + (f) => { + const o = JSON.stringify(f.outer), + s = JSON.stringify(f.seal), + r = JSON.stringify(f.rumor); + assert.equal( + verifyReceivedLayerData( + ' ' + o + '\n', + '\n' + s, + JSON.stringify(f.rumor, null, 2), + f.owner + ), + true + ); + assert.equal( + verifyReceivedLayerData( + o, + s, + r.replace('"kind":14', '"kind":15,"kind":14'), + f.owner + ), + false + ); + assert.equal( + verifyReceivedLayerData(o, s, r.replace('1700000000', '17e8'), f.owner), + false + ); + assert.deepEqual( + [ + verifyReceivedLayerData(o, s, '{}', f.owner), + verifyReceivedLayerData(o, s, r, f.owner) + ], + [false, true] + ); + } +); diff --git a/web/tests/e2e/harness/received-envelopes.ts b/web/tests/e2e/harness/received-envelopes.ts @@ -0,0 +1,149 @@ +import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts'; +import { + createPrivateSession, + closePrivateSession +} from '../../../src/lib/runtime/private-session.ts'; +import { + admitInboxEnvelope, + retainInboxEnvelope +} from '../../../src/lib/persistence/inbox-envelope-repository.ts'; +import { + loadPrivateRecord, + commitPrivateRecord +} from '../../../src/lib/persistence/private-storage.ts'; +import { + privateRecordSnapshot, + decodePrivateRecord +} from '../../../src/lib/persistence/private-records.ts'; +import { + captureReceivedUnwrap, + unwrapReceivedEnvelope, + stopReceivedUnwrap, + receivedNestedEnvelopeSnapshot, + type ReceivedUnwrap, + type ReceivedNestedEnvelope +} from '../../../src/lib/nostr/unwrap-admission.ts'; +export async function makeFixture() { + const f = await makeRecoveryFixture(), + privateSession = await createPrivateSession( + f.identity, + 'reviewed_private_session' + ); + if (!privateSession) throw Error('missing genuine private session'); + const self = (await f.row())!.record.self, + admitted = admitInboxEnvelope( + self.wire, + f.owner, + 'wss://archive.example.org', + 100 + ); + if (!admitted) throw Error('missing admitted real outer'); + const saved = await retainInboxEnvelope( + f.repository, + privateSession, + admitted + ); + if (saved.status !== 'retained' && saved.status !== 'duplicate') + throw Error('no actual retained outer'); + let reader: ReceivedUnwrap | undefined, + proof: ReceivedNestedEnvelope | undefined; + let releaseKey: (() => void) | undefined; + let restoreKey = () => {}; + return { + ...f, + outerId: self.eventId, + capture(review: unknown = 'reviewed_inbox_unlock') { + reader = captureReceivedUnwrap( + f.repository, + f.identity, + self.eventId, + review + ); + return !!reader; + }, + async run() { + if (!reader) return { status: 'invalid' as const }; + const result = await unwrapReceivedEnvelope(reader); + if (result.status === 'authenticated') proof = result.envelope; + return { + status: result.status, + snapshot: proof && receivedNestedEnvelopeSnapshot(proof) + }; + }, + stop() { + if (reader) stopReceivedUnwrap(reader); + }, + snapshot() { + return proof && receivedNestedEnvelopeSnapshot(proof); + }, + forged() { + return receivedNestedEnvelopeSnapshot({} as ReceivedNestedEnvelope); + }, + holdFinalKey() { + const provider = window.nostr as + { getPublicKey: () => Promise<string> } | undefined; + if (!provider) throw Error('missing actual fixture provider'); + const original = provider.getPublicKey; + let calls = 0; + provider.getPublicKey = async () => { + const owner = await original.call(provider); + calls++; + return calls === 3 + ? new Promise<string>((resolve) => { + releaseKey = () => resolve(owner); + }) + : owner; + }; + restoreKey = () => { + provider.getPublicKey = original; + }; + }, + pendingFinalKey: () => !!releaseKey, + settleFinalKey() { + const release = releaseKey; + releaseKey = undefined; + release?.(); + }, + countsValue: () => f.counts(), + async stored() { + const row = await loadPrivateRecord( + f.repository, + 'received_envelopes', + self.eventId + ); + return row.ok + ? privateRecordSnapshot(row.value, f.owner, self.eventId) + : undefined; + }, + async changeObservedSource() { + const old = await loadPrivateRecord( + f.repository, + 'received_envelopes', + self.eventId + ); + if (!old.ok) throw Error('missing actual received row'); + const record = privateRecordSnapshot(old.value, f.owner, self.eventId); + if (!record || record.family !== 'received_envelope') + throw Error('wrong received row'); + const next = decodePrivateRecord( + JSON.stringify({ + ...record, + revision: record.revision + 1, + sources: [...record.sources, 'wss://peer-inbox.example.org'] + }), + f.owner, + self.eventId + ); + if (!next.ok) throw Error('invalid controlled metadata successor'); + return commitPrivateRecord(f.repository, next.value, old.value); + }, + close() { + releaseKey?.(); + releaseKey = undefined; + restoreKey(); + if (reader) stopReceivedUnwrap(reader); + closePrivateSession(privateSession); + f.close(); + } + }; +} diff --git a/web/tests/e2e/received-envelopes.spec.ts b/web/tests/e2e/received-envelopes.spec.ts @@ -0,0 +1,240 @@ +import { test, expect } from '@playwright/test'; +import { build } from 'vite'; +import { fileURLToPath } from 'node:url'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/received-envelopes.ts'; +declare global { + interface Window { + hcp091: typeof Fixture; + hcp091Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>; + hcp091Run?: ReturnType< + Awaited<ReturnType<typeof Fixture.makeFixture>>['run'] + >; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string; +test.beforeAll(async () => { + server = await createStaticHarness(); + const result = await build({ + configFile: false, + logLevel: 'silent', + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/received-envelopes.ts', import.meta.url) + ), + name: 'hcp091', + formats: ['iife'] + } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw Error('bundle missing'); + const chunks = output.output.filter((x) => x.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; +}); +test.afterAll(async () => { + await server.close(); +}); +test.beforeEach(async ({ page }) => { + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + await page.evaluate(async () => { + window.hcp091Fixture = await window.hcp091.makeFixture(); + }); +}); +test.afterEach(async ({ page }) => { + if (!page.isClosed()) + await page.evaluate(() => window.hcp091Fixture?.close()); +}); +test('stored actual ciphertext is explicitly unlocked with two stock SDK decryptions and no plaintext persistence', async ({ + page +}) => { + const before = await page.evaluate(() => window.hcp091Fixture.countsValue()); + const result = await page.evaluate(async () => { + const f = window.hcp091Fixture; + f.capture(); + const result = await f.run(); + return { + result, + counts: f.countsValue(), + stored: await f.stored(), + forged: f.forged() + }; + }); + expect(result.result.status).toBe('authenticated'); + expect(result.result.snapshot).toBeDefined(); + expect(result.counts.decrypts).toBe(before.decrypts + 2); + expect(result.counts.keys).toBeGreaterThan(before.keys + 1); + expect(result.counts.encrypts).toBe(before.encrypts); + expect(result.counts.signs).toBe(before.signs); + expect(result.stored).toMatchObject({ + family: 'received_envelope', + read: null + }); + expect(result.stored).not.toHaveProperty('body'); + expect(result.forged).toBeUndefined(); +}); +test('absent explicit unlock cannot capture or decrypt', async ({ page }) => { + const r = await page.evaluate(async () => { + const f = window.hcp091Fixture, + before = f.countsValue(); + return { + capture: f.capture('unreviewed'), + result: await f.run(), + before, + after: f.countsValue() + }; + }); + expect(r.capture).toBe(false); + expect(r.result.status).toBe('invalid'); + expect(r.after).toEqual(r.before); +}); +test('one invalid decrypted seal is isolated and a later explicit valid candidate remains usable', async ({ + page +}) => { + const r = await page.evaluate(async () => { + const f = window.hcp091Fixture; + f.mode('wrong_plaintext'); + f.capture(); + const bad = await f.run(); + f.mode('normal'); + f.capture(); + const good = await f.run(); + return { bad, good }; + }); + expect(r.bad.status).toBe('mismatch'); + expect(r.bad.snapshot).toBeUndefined(); + expect(r.good.status).toBe('authenticated'); +}); +test('changed fresh extension owner fences the first decrypt', async ({ + page +}) => { + const r = await page.evaluate(async () => { + const f = window.hcp091Fixture, + before = f.countsValue(); + f.mode('changed_key'); + f.capture(); + const result = await f.run(); + return { result, before, after: f.countsValue() }; + }); + expect(r.result.status).toBe('stopped'); + expect(r.after.decrypts).toBe(r.before.decrypts); + expect(r.result.snapshot).toBeUndefined(); +}); +test('actual decryption refusal has no nested proof or automatic follow-up', async ({ + page +}) => { + const r = await page.evaluate(async () => { + const f = window.hcp091Fixture, + before = f.countsValue(); + f.mode('declined_decrypt'); + f.capture(); + const result = await f.run(); + return { result, before, after: f.countsValue() }; + }); + expect(r.result.status).toBe('refused'); + expect(r.after.decrypts).toBe(r.before.decrypts + 1); + expect(r.result.snapshot).toBeUndefined(); +}); +test('Stop during actual provider wait cannot mint a proof or schedule inner decryption', async ({ + page +}) => { + const before = await page.evaluate(() => { + const f = window.hcp091Fixture; + f.mode('hold_decrypt'); + f.capture(); + window.hcp091Run = f.run(); + return f.countsValue(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp091Fixture.pending())) + .toBe(true); + const r = await page.evaluate(async () => { + const f = window.hcp091Fixture; + f.stop(); + f.settle(); + return { + result: await window.hcp091Run, + counts: f.countsValue(), + snapshot: f.snapshot() + }; + }); + expect(r.result?.status).toBe('stopped'); + expect(r.counts.decrypts).toBe(before.decrypts + 1); + expect(r.snapshot).toBeUndefined(); +}); +test('logout during actual provider wait destroys session-owned nested evidence', async ({ + page +}) => { + await page.evaluate(() => { + const f = window.hcp091Fixture; + f.mode('hold_decrypt'); + f.capture(); + window.hcp091Run = f.run(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp091Fixture.pending())) + .toBe(true); + const result = await page.evaluate(async () => { + const f = window.hcp091Fixture; + f.disconnect(); + f.settle(); + return await window.hcp091Run; + }); + expect(result?.status).toBe('stopped'); + expect(result?.snapshot).toBeUndefined(); +}); +test('changed actual stored full-wire metadata during decrypt invalidates original custody', async ({ + page +}) => { + await page.evaluate(() => { + const f = window.hcp091Fixture; + f.mode('hold_decrypt'); + f.capture(); + window.hcp091Run = f.run(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp091Fixture.pending())) + .toBe(true); + expect( + await page.evaluate(async () => { + const f = window.hcp091Fixture; + const result = await f.changeObservedSource(); + f.mode('normal'); + f.settle(); + return result.ok; + }) + ).toBe(true); + const result = await page.evaluate(async () => await window.hcp091Run); + expect(result?.status).toBe('conflict'); + expect(result?.snapshot).toBeUndefined(); +}); + +test('actual stored-wire change during held final SDK key check cannot mint current nested custody', async ({ + page +}) => { + await page.evaluate(() => { + const f = window.hcp091Fixture; + f.holdFinalKey(); + f.capture(); + window.hcp091Run = f.run(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp091Fixture.pendingFinalKey())) + .toBe(true); + expect( + await page.evaluate(async () => { + const f = window.hcp091Fixture; + const changed = await f.changeObservedSource(); + f.settleFinalKey(); + return changed.ok; + }) + ).toBe(true); + const result = await page.evaluate(async () => await window.hcp091Run); + expect(result?.status).toBe('conflict'); + expect(result?.snapshot).toBeUndefined(); +});