app

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

commit 98c2ffc30cd752949118153c78b57386e5df2fd7
parent d330d89347a7b6d83a4562477253a1923dd6e2af
Author: triesap <tyson@radroots.org>
Date:   Wed,  7 Oct 2026 20:59:22 +0000

messages: verify genuine outbound nested envelopes (HCP-077)

- Compare actual seal and wrapper decryptions to immutable originals
- Verify fresh signatures hashes participants and reservation binding
- Fence Stop expiry and disconnect through actual decrypt settlement
- Qualify genuine proofs rejection cleanup and controlled fixture clocks

Diffstat:
Mweb/src/lib/nostr/giftwrap-builder.ts | 12++++++++++++
Aweb/src/lib/nostr/outbound-envelope-layers.ts | 99+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/nostr/seal-builder.ts | 22+++++++++++++++++++++-
Aweb/src/lib/nostr/verify-outbound-envelope.ts | 76++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/conformance/outbound-envelope-layers.test.ts | 154+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/harness/giftwrap-builder.ts | 89+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------
Aweb/tests/e2e/harness/outbound-envelope.ts | 5+++++
Mweb/tests/e2e/harness/seal-builder.ts | 77+++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------
Aweb/tests/e2e/outbound-envelope.spec.ts | 191+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/seal-builder.spec.ts | 11++++++++---
Mweb/tests/provenance/source-boundaries.test.mjs | 5++++-
Mweb/tests/unit/giftwrap-builder.test.ts | 20++++++++++++++++++++
Mweb/tools/source-boundaries.mjs | 2+-
13 files changed, 717 insertions(+), 46 deletions(-)

diff --git a/web/src/lib/nostr/giftwrap-builder.ts b/web/src/lib/nostr/giftwrap-builder.ts @@ -67,6 +67,11 @@ export function buildPrivateGiftwrap( if (!privateSealSnapshot(seal)) return undefined; const content = nip44.v2.encrypt(record.wire, conversation); if (!privateSealSnapshot(seal)) return undefined; + if ( + nip44.v2.decrypt(content, conversation) !== record.wire || + !privateSealSnapshot(seal) + ) + return undefined; const captured = JSON.stringify({ pubkey: author, kind: 1059, @@ -140,6 +145,13 @@ export function buildPrivateGiftwrap( secret?.fill(0); } } +// Returns only the genuine original capability, never disposable key material. +export function privateGiftwrapSeal( + token: PrivateGiftwrap +): PrivateRecipientSeal | undefined { + const saved = wraps.get(token); + return saved && privateSealSnapshot(saved.seal) ? saved.seal : undefined; +} export function privateGiftwrapSnapshot( token: PrivateGiftwrap ): Readonly<Omit<Saved, 'seal'>> | undefined { diff --git a/web/src/lib/nostr/outbound-envelope-layers.ts b/web/src/lib/nostr/outbound-envelope-layers.ts @@ -0,0 +1,99 @@ +import { getEventHash, type UnsignedEvent } from 'applesauce-core/helpers'; +import { canonicalPublicKey } from '../contracts/public-key.ts'; +import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts'; +import { + messageFromWireParts, + messageToWireParts +} from '../contracts/message-v1/index.ts'; +import { safeUnsignedInteger } from './envelope-bounds.ts'; +import { verifyEnvelope } from './verified-envelope.ts'; + +function fields( + value: unknown, + names: string[] +): value is Record<string, unknown> { + if (typeof value !== 'object' || value === null || Array.isArray(value)) + return false; + let count = 0; + for (const name in value) { + if (!names.includes(name)) return false; + count++; + } + return count === names.length && names.every((name) => name in value); +} +// Detached structural/signature inspection only. Ciphertext correspondence and +// genuine original reservation custody belong to the factory-owned proof. +export function verifyOutboundLayerData( + original: unknown, + rumorWire: unknown, + sealWire: unknown, + outerWire: unknown, + author: unknown, + recipient: unknown, + role: unknown +): boolean { + const owner = canonicalPublicKey(author), + peer = canonicalPublicKey(recipient); + if ( + !owner || + !peer || + owner === peer || + (role !== 'peer' && role !== 'self') || + typeof original !== 'string' || + typeof rumorWire !== 'string' || + original !== rumorWire || + !boundedUtf8(rumorWire, 8192) || + typeof sealWire !== 'string' || + !boundedUtf8(sealWire, 16384) || + typeof outerWire !== 'string' || + !boundedUtf8(outerWire, 32768) + ) + return false; + try { + const rumor: unknown = JSON.parse(rumorWire), + seal: unknown = JSON.parse(sealWire), + outer: unknown = JSON.parse(outerWire); + const unsigned = ['id', 'pubkey', 'created_at', 'kind', 'tags', 'content'], + signed = [...unsigned, 'sig']; + if ( + !fields(rumor, unsigned) || + !fields(seal, signed) || + !fields(outer, signed) || + rumor.pubkey !== owner || + rumor.kind !== 14 || + safeUnsignedInteger(rumor.created_at) === undefined || + seal.pubkey !== owner || + seal.kind !== 13 || + !Array.isArray(seal.tags) || + seal.tags.length !== 0 || + outer.kind !== 1059 || + !Array.isArray(outer.tags) || + JSON.stringify(outer.tags) !== + JSON.stringify([['p', role === 'self' ? owner : peer]]) || + !verifyEnvelope(sealWire).ok || + !verifyEnvelope(outerWire).ok + ) + return false; + const parts = { kind: 14, tags: rumor.tags, content: rumor.content }; + const decoded = messageFromWireParts(JSON.stringify(parts)); + if ( + !decoded || + decoded.recipients.length !== 1 || + decoded.recipients[0].public_key !== peer + ) + return false; + const canonical = messageToWireParts(JSON.stringify(decoded)); + if (!canonical || JSON.stringify(canonical) !== JSON.stringify(parts)) + return false; + const template: UnsignedEvent = { + pubkey: owner, + created_at: rumor.created_at as number, + kind: 14, + tags: canonical.tags.map((row) => [...row]), + content: canonical.content + }; + return typeof rumor.id === 'string' && rumor.id === getEventHash(template); + } catch { + return false; + } +} diff --git a/web/src/lib/nostr/seal-builder.ts b/web/src/lib/nostr/seal-builder.ts @@ -46,6 +46,7 @@ type SavedSeal = Readonly<{ command: string; rumorHash: string; wire: string; + reserved: ReservedSendIdentity; current(): boolean; }>; const operations = new WeakMap<PrivateSealOperation, State>(); @@ -165,6 +166,17 @@ export function capturePrivateSealOperation( return { status: encrypted.status === 'denied' ? 'refused' : 'stopped' }; if (!sealCiphertextV2(encrypted.value)) return { status: 'mismatch' }; if (!(await fresh(action))) return { status: 'stopped' }; + const decryptPort = cipherPort(); + if (!decryptPort || !current()) return { status: 'stopped' }; + const decrypted = await callExtension(action, 'decrypt', () => + decryptPort.decrypt(target, encrypted.value) + ); + if (!current()) return { status: 'stopped' }; + if (decrypted.status !== 'settled' || !decrypted.current) + return { status: decrypted.status === 'denied' ? 'refused' : 'stopped' }; + if (decrypted.value !== wire || reservedSendRumorWire(reserved) !== wire) + return { status: 'mismatch' }; + if (!(await fresh(action))) return { status: 'stopped' }; const milliseconds = safeUnsignedInteger(Date.now()); if (milliseconds === undefined || !current()) return { status: 'stopped' }; // Public randomized timing metadata only. Never change the reserved inner @@ -193,6 +205,7 @@ export function capturePrivateSealOperation( command: record.id, rumorHash: record.rumorHash, wire: signed, + reserved, current }); return { status: 'sealed', seal }; @@ -257,7 +270,7 @@ export function expirePrivateSealWait(operation: PrivateSealOperation): void { // Future wrapper/nested owners must retain exact original operation binding. export function privateSealSnapshot( seal: PrivateRecipientSeal -): Readonly<Omit<SavedSeal, 'current'>> | undefined { +): Readonly<Omit<SavedSeal, 'current' | 'reserved'>> | undefined { const saved = seals.get(seal); return saved?.current() ? { @@ -271,3 +284,10 @@ export function privateSealSnapshot( } : undefined; } +// Genuine association only; detached snapshots cannot recreate this identity. +export function privateSealReservation( + seal: PrivateRecipientSeal +): ReservedSendIdentity | undefined { + const saved = seals.get(seal); + return saved?.current() ? saved.reserved : undefined; +} diff --git a/web/src/lib/nostr/verify-outbound-envelope.ts b/web/src/lib/nostr/verify-outbound-envelope.ts @@ -0,0 +1,76 @@ +import { + reservedSendSnapshot, + reservedSendRumorWire, + type ReservedSendIdentity +} from '../messaging/send-identity.ts'; +import { + privateGiftwrapSnapshot, + privateGiftwrapSeal, + type PrivateGiftwrap +} from './giftwrap-builder.ts'; +import { privateSealSnapshot, privateSealReservation } from './seal-builder.ts'; +import { verifyOutboundLayerData } from './outbound-envelope-layers.ts'; +declare const outboundBrand: unique symbol; +export type VerifiedOutboundEnvelope = Readonly<{ [outboundBrand]: true }>; +type Saved = Readonly<{ + reserved: ReservedSendIdentity; + wrap: PrivateGiftwrap; +}>; +const proofs = new WeakMap<VerifiedOutboundEnvelope, Saved>(); +function inspect(reserved: ReservedSendIdentity, wrap: PrivateGiftwrap) { + const record = reservedSendSnapshot(reserved), + rumor = reservedSendRumorWire(reserved), + outer = privateGiftwrapSnapshot(wrap), + seal = privateGiftwrapSeal(wrap), + inner = seal && privateSealSnapshot(seal); + if ( + !record || + !rumor || + !outer || + !seal || + !inner || + privateSealReservation(seal) !== reserved || + outer.command !== record.id || + outer.owner !== record.owner || + outer.peer !== record.peer || + outer.rumorHash !== record.rumorHash || + inner.command !== outer.command || + inner.rumorHash !== outer.rumorHash || + inner.role !== outer.role || + inner.destination !== outer.destination || + !verifyOutboundLayerData( + rumor, + rumor, + inner.wire, + outer.wire, + record.owner, + record.peer, + outer.role + ) + ) + return undefined; + const original = JSON.parse(rumor) as { id: string; created_at: number }; + if ( + original.id !== record.rumorHash || + original.created_at !== record.createdAt + ) + return undefined; + return outer; +} +// Only genuine current factory roundtrip associations enter this proof. Pure +// detached validation cannot mint it. No receipt, durability or Send follows. +export function verifyOutboundEnvelope( + reserved: ReservedSendIdentity, + wrap: PrivateGiftwrap, + review: unknown +): VerifiedOutboundEnvelope | undefined { + if (review !== 'reviewed_outbound_layers' || !inspect(reserved, wrap)) + return undefined; + const token = Object.freeze({}) as VerifiedOutboundEnvelope; + proofs.set(token, { reserved, wrap }); + return token; +} +export function verifiedOutboundSnapshot(token: VerifiedOutboundEnvelope) { + const saved = proofs.get(token); + return saved ? inspect(saved.reserved, saved.wrap) : undefined; +} diff --git a/web/tests/conformance/outbound-envelope-layers.test.ts b/web/tests/conformance/outbound-envelope-layers.test.ts @@ -0,0 +1,154 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { + generateSecretKey, + getPublicKey, + getEventHash, + finalizeEvent, + type UnsignedEvent +} from 'applesauce-core/helpers'; +import { verifyOutboundLayerData } from '../../src/lib/nostr/outbound-envelope-layers.ts'; + +// Detached real SDK signature vectors only; no genuine preparation authority. +function fixture() { + const keys = [generateSecretKey(), generateSecretKey(), generateSecretKey()]; + const owner = getPublicKey(keys[0]), + peer = getPublicKey(keys[1]); + const template: UnsignedEvent = { + pubkey: owner, + kind: 14, + created_at: 1700000000, + tags: [['p', peer]], + content: 'Original enquiry' + }; + const rumor = { id: getEventHash(template), ...template }; + const seal = finalizeEvent( + { + kind: 13, + created_at: 1699999900, + tags: [], + content: 'bounded ciphertext fixture' + }, + keys[0] + ); + const outer = finalizeEvent( + { + kind: 1059, + created_at: 1699999800, + tags: [['p', peer]], + content: 'bounded outer fixture' + }, + keys[2] + ); + const original = JSON.stringify(rumor); + const check = ( + r: unknown = rumor, + s: unknown = seal, + w: unknown = outer, + role: 'peer' | 'self' = 'peer' + ) => + verifyOutboundLayerData( + original, + JSON.stringify(r), + JSON.stringify(s), + JSON.stringify(w), + owner, + peer, + role + ); + return { + keys, + owner, + peer, + rumor, + seal, + outer, + check, + close: () => keys.forEach((k) => k.fill(0)) + }; +} +await test('fresh SDK hashes and both signed layers preserve the exact original pair rumor', () => { + const f = fixture(); + try { + assert.equal(f.check(), true); + const self = finalizeEvent( + { + kind: 1059, + created_at: f.outer.created_at, + tags: [['p', f.owner]], + content: f.outer.content + }, + f.keys[2] + ); + assert.equal(f.check(f.rumor, f.seal, self, 'self'), true); + } finally { + f.close(); + } +}); +await test('valid signatures do not admit wrong sender, seal tags or outer target', () => { + const f = fixture(); + try { + assert.equal( + f.check(f.rumor, finalizeEvent({ ...f.seal }, f.keys[1])), + false + ); + assert.equal( + f.check( + f.rumor, + finalizeEvent({ ...f.seal, tags: [['client', 'leak']] }, f.keys[0]) + ), + false + ); + assert.equal( + f.check( + f.rumor, + f.seal, + finalizeEvent({ ...f.outer, tags: [['p', f.owner]] }, f.keys[2]) + ), + false + ); + assert.equal( + f.check( + f.rumor, + f.seal, + finalizeEvent( + { + ...f.outer, + tags: [ + ['p', f.peer], + ['p', f.owner] + ] + }, + f.keys[2] + ) + ), + false + ); + } finally { + f.close(); + } +}); +await test('rehashed substitute rumor, third-party fanout and cached wrong ids fail', () => { + const f = fixture(); + try { + const substitute = { ...f.rumor, content: 'different enquiry' }; + substitute.id = getEventHash(substitute); + assert.equal(f.check(substitute), false); + const fanout = { + ...f.rumor, + tags: [ + ['p', f.peer], + ['p', f.owner] + ] + }; + fanout.id = getEventHash(fanout); + assert.equal(f.check(fanout), false); + assert.equal(f.check({ ...f.rumor, id: '0'.repeat(64) }), false); + assert.equal( + f.check(f.rumor, { ...f.seal, id: '0'.repeat(64), verified: true }), + false + ); + } finally { + f.close(); + } +}); diff --git a/web/tests/e2e/harness/giftwrap-builder.ts b/web/tests/e2e/harness/giftwrap-builder.ts @@ -61,6 +61,9 @@ export type Mode = | 'changed_key' | 'hold_encrypt' | 'hold_sign' + | 'wrong_plaintext' + | 'declined_decrypt' + | 'hold_decrypt' | 'getter_reentry' | 'stop_capability_getter' | 'stop_capability_after_key'; @@ -75,6 +78,7 @@ export async function makeFixture() { keys = 0, encrypts = 0, signs = 0, + decrypts = 0, capabilityReads = 0, reentrantReads = 0, postStopEncrypts = 0, @@ -161,19 +165,34 @@ export async function makeFixture() { return new Promise<string>((resolve) => { release = () => resolve(encryptTo(target, text)); }); - return Promise.resolve(encryptTo(target, text)); + return Promise.resolve( + encryptTo( + target, + mode === 'wrong_plaintext' ? 'substitute rumor' : text + ) + ); }; }, decrypt: (target: string, cipher: string) => { - const conversation = nip44.v2.utils.getConversationKey( - secret, - target - ); - try { - return Promise.resolve(nip44.v2.decrypt(cipher, conversation)); - } finally { - conversation.fill(0); - } + decrypts++; + if (mode === 'declined_decrypt') + return Promise.reject(Error('decrypt refused')); + const decryptNow = () => { + const conversation = nip44.v2.utils.getConversationKey( + secret, + target + ); + try { + return nip44.v2.decrypt(cipher, conversation); + } finally { + conversation.fill(0); + } + }; + if (mode === 'hold_decrypt') + return new Promise<string>((resolve) => { + release = () => resolve(decryptNow()); + }); + return Promise.resolve(decryptNow()); } }; } @@ -207,11 +226,12 @@ export async function makeFixture() { if (!proof.ok) throw Error('invalid public fixture'); const context = captureEnquiryContext(proof.value); if (!context) throw Error('invalid context'); + const reservationTime = Date.now(); const plan = captureEnquiryRumor( identity, context, 'Private seal sentinel', - Math.floor(Date.now() / 1000) + Math.floor(reservationTime / 1000) ); if (!plan) throw Error('missing plan'); const opened = await openBrowserDatabase(); @@ -219,14 +239,24 @@ export async function makeFixture() { const database = opened.owner, repository = createPrivateSendReservationRepository(database, owner); if (!repository) throw Error('missing repository'); - const reservation = await reserveSendIdentity( - repository, - identity, - '12345678-1234-4234-8234-123456789abc', - plan, - 'reviewed_private_intent' - ); - if (reservation.status !== 'reserved') throw Error('missing reservation'); + // Controlled fixture second across actual asynchronous IDB/WebLock setup. + // Production admission still requires its real current observed second. + const liveNow = Date.now; + let reservation: Awaited<ReturnType<typeof reserveSendIdentity>>; + Date.now = () => reservationTime; + try { + reservation = await reserveSendIdentity( + repository, + identity, + '12345678-1234-4234-8234-123456789abc', + plan, + 'reviewed_private_intent' + ); + } finally { + Date.now = liveNow; + } + if (reservation.status !== 'reserved') + throw Error('missing reservation: ' + reservation.status); const reserved = reservation.identity; const original = reservedSendRumorWire(reserved); return { @@ -234,6 +264,18 @@ export async function makeFixture() { peer, identity, reserved, + async reserveAgain() { + const result = await reserveSendIdentity( + repository, + identity, + '12345678-1234-4234-8234-123456789abc', + plan, + 'reviewed_private_intent' + ); + if (result.status !== 'existing' && result.status !== 'reserved') + throw Error('missing second reservation'); + return result.identity; + }, operation: ( role: unknown = 'peer', review: unknown = 'reviewed_private_seal' @@ -245,7 +287,14 @@ export async function makeFixture() { mode = value; capabilityReads = 0; }, - counts: () => ({ keys, encrypts, signs, reentrantReads, postStopEncrypts }), + counts: () => ({ + keys, + encrypts, + decrypts, + signs, + reentrantReads, + postStopEncrypts + }), identityState: () => identitySessionSnapshot(identity).state, settle: () => { release?.(); diff --git a/web/tests/e2e/harness/outbound-envelope.ts b/web/tests/e2e/harness/outbound-envelope.ts @@ -0,0 +1,5 @@ +export * from './giftwrap-builder.ts'; +export { + verifyOutboundEnvelope, + verifiedOutboundSnapshot +} from '../../../src/lib/nostr/verify-outbound-envelope.ts'; diff --git a/web/tests/e2e/harness/seal-builder.ts b/web/tests/e2e/harness/seal-builder.ts @@ -56,6 +56,9 @@ export type Mode = | 'changed_key' | 'hold_encrypt' | 'hold_sign' + | 'wrong_plaintext' + | 'declined_decrypt' + | 'hold_decrypt' | 'getter_reentry' | 'stop_capability_getter' | 'stop_capability_after_key'; @@ -70,6 +73,7 @@ export async function makeFixture() { keys = 0, encrypts = 0, signs = 0, + decrypts = 0, capabilityReads = 0, reentrantReads = 0, postStopEncrypts = 0, @@ -156,19 +160,34 @@ export async function makeFixture() { return new Promise<string>((resolve) => { release = () => resolve(encryptTo(target, text)); }); - return Promise.resolve(encryptTo(target, text)); + return Promise.resolve( + encryptTo( + target, + mode === 'wrong_plaintext' ? 'substitute rumor' : text + ) + ); }; }, decrypt: (target: string, cipher: string) => { - const conversation = nip44.v2.utils.getConversationKey( - secret, - target - ); - try { - return Promise.resolve(nip44.v2.decrypt(cipher, conversation)); - } finally { - conversation.fill(0); - } + decrypts++; + if (mode === 'declined_decrypt') + return Promise.reject(Error('decrypt refused')); + const decryptNow = () => { + const conversation = nip44.v2.utils.getConversationKey( + secret, + target + ); + try { + return nip44.v2.decrypt(cipher, conversation); + } finally { + conversation.fill(0); + } + }; + if (mode === 'hold_decrypt') + return new Promise<string>((resolve) => { + release = () => resolve(decryptNow()); + }); + return Promise.resolve(decryptNow()); } }; } @@ -202,11 +221,12 @@ export async function makeFixture() { if (!proof.ok) throw Error('invalid public fixture'); const context = captureEnquiryContext(proof.value); if (!context) throw Error('invalid context'); + const reservationTime = Date.now(); const plan = captureEnquiryRumor( identity, context, 'Private seal sentinel', - Math.floor(Date.now() / 1000) + Math.floor(reservationTime / 1000) ); if (!plan) throw Error('missing plan'); const opened = await openBrowserDatabase(); @@ -214,14 +234,24 @@ export async function makeFixture() { const database = opened.owner, repository = createPrivateSendReservationRepository(database, owner); if (!repository) throw Error('missing repository'); - const reservation = await reserveSendIdentity( - repository, - identity, - '12345678-1234-4234-8234-123456789abc', - plan, - 'reviewed_private_intent' - ); - if (reservation.status !== 'reserved') throw Error('missing reservation'); + // Controlled fixture second across actual asynchronous IDB/WebLock setup. + // Production admission still requires its real current observed second. + const liveNow = Date.now; + let reservation: Awaited<ReturnType<typeof reserveSendIdentity>>; + Date.now = () => reservationTime; + try { + reservation = await reserveSendIdentity( + repository, + identity, + '12345678-1234-4234-8234-123456789abc', + plan, + 'reviewed_private_intent' + ); + } finally { + Date.now = liveNow; + } + if (reservation.status !== 'reserved') + throw Error('missing reservation: ' + reservation.status); const reserved = reservation.identity; const original = reservedSendRumorWire(reserved); return { @@ -240,7 +270,14 @@ export async function makeFixture() { mode = value; capabilityReads = 0; }, - counts: () => ({ keys, encrypts, signs, reentrantReads, postStopEncrypts }), + counts: () => ({ + keys, + encrypts, + decrypts, + signs, + reentrantReads, + postStopEncrypts + }), identityState: () => identitySessionSnapshot(identity).state, settle: () => { release?.(); diff --git a/web/tests/e2e/outbound-envelope.spec.ts b/web/tests/e2e/outbound-envelope.spec.ts @@ -0,0 +1,191 @@ +import { test, expect, type Page } from '@playwright/test'; +import { build } from 'vite'; +import { fileURLToPath } from 'node:url'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Layers from './harness/outbound-envelope.ts'; +declare global { + interface Window { + hcp077: typeof Layers; + hcp077Fixture: Awaited<ReturnType<typeof Layers.makeFixture>>; + hcp077Operation: Parameters<typeof Layers.stopPrivateSeal>[0]; + hcp077Job: ReturnType<typeof Layers.buildPrivateSeal>; + } +} +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/outbound-envelope.ts', import.meta.url) + ), + name: 'hcp077', + formats: ['iife'] + } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw Error('missing bundle'); + const chunks = output.output.filter((x) => x.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; +}); +test.afterAll(async () => server.close()); +async function load(page: Page) { + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + await page.evaluate(async () => { + window.hcp077Fixture = await window.hcp077.makeFixture(); + }); +} +for (const role of ['peer', 'self'] as const) + test(`genuine ${role} nested proof binds original reservation and expires on disconnect`, async ({ + page + }) => { + await load(page); + const result = await page.evaluate(async (role) => { + const f = window.hcp077Fixture, + s = window.hcp077; + try { + const op = f.operation(role); + if (!op) throw Error('missing operation'); + const sealed = await s.buildPrivateSeal(op); + if (sealed.status !== 'sealed') throw Error('missing seal'); + const wrap = s.buildPrivateGiftwrap( + sealed.seal, + 'reviewed_private_wrap' + ); + if (!wrap) throw Error('missing wrap'); + const proof = s.verifyOutboundEnvelope( + f.reserved, + wrap, + 'reviewed_outbound_layers' + ); + const snapshot = proof && s.verifiedOutboundSnapshot(proof); + const cast = s.verifyOutboundEnvelope( + f.reserved, + {} as typeof wrap, + 'reviewed_outbound_layers' + ); + const wrongReview = s.verifyOutboundEnvelope(f.reserved, wrap, 'wrong'); + const second = await f.reserveAgain(); + const wrongReservation = s.verifyOutboundEnvelope( + second, + wrap, + 'reviewed_outbound_layers' + ); + f.disconnect(); + return { + admitted: !!snapshot, + role: snapshot?.role, + cast: !!cast, + wrongReview: !!wrongReview, + differentGenuineReservation: second !== f.reserved, + wrongReservation: !!wrongReservation, + expired: proof && !s.verifiedOutboundSnapshot(proof) + }; + } finally { + f.close(); + } + }, role); + expect(result).toEqual({ + admitted: true, + role, + cast: false, + wrongReview: false, + differentGenuineReservation: true, + wrongReservation: false, + expired: true + }); + }); +for (const mode of ['wrong_plaintext', 'declined_decrypt'] as const) + test(`actual ${mode} never spends SIGN or grants a sender seal`, async ({ + page + }) => { + await load(page); + const result = await page.evaluate(async (mode) => { + const f = window.hcp077Fixture; + try { + const op = f.operation(); + if (!op) throw Error('missing operation'); + f.mode(mode); + const before = f.counts(), + identity = f.identityState(); + const result = await window.hcp077.buildPrivateSeal(op), + after = f.counts(); + return { + status: result.status, + signs: after.signs - before.signs, + decrypts: after.decrypts - before.decrypts, + identityPreserved: f.identityState() === identity + }; + } finally { + f.close(); + } + }, mode); + expect(result.status).toBe( + mode === 'wrong_plaintext' ? 'mismatch' : 'refused' + ); + expect(result.signs).toBe(0); + expect(result.decrypts).toBe(1); + expect(result.identityPreserved).toBe(true); + }); +for (const action of ['stop', 'expire'] as const) + test(`${action} during actual decrypt keeps slot and owner lock until settlement without late SIGN`, async ({ + page + }) => { + await load(page); + await page.evaluate(() => { + const f = window.hcp077Fixture, + op = f.operation(); + if (!op) throw Error('missing operation'); + f.mode('hold_decrypt'); + window.hcp077Operation = op; + window.hcp077Job = window.hcp077.buildPrivateSeal(op); + }); + await expect + .poll(() => page.evaluate(() => window.hcp077Fixture.slot())) + .toMatchObject({ state: 'active', pending: 'decrypt' }); + const pending = await page.evaluate(async (action) => { + const f = window.hcp077Fixture, + s = window.hcp077, + identity = f.identityState(); + if (action === 'expire') s.expirePrivateSealWait(window.hcp077Operation); + else s.stopPrivateSeal(window.hcp077Operation); + const other = f.operation(); + if (!other) throw Error('missing contender'); + return { + slot: f.slot(), + busy: (await s.buildPrivateSeal(other)).status, + identityPreserved: f.identityState() === identity + }; + }, action); + expect(pending.slot).toMatchObject({ state: 'active', pending: 'decrypt' }); + expect(pending.busy).toBe('busy'); + expect(pending.identityPreserved).toBe(true); + const settled = await page.evaluate(async () => { + const f = window.hcp077Fixture, + before = f.counts(); + try { + f.settle(); + const result = await window.hcp077Job; + return { + status: result.status, + slot: f.slot(), + unchanged: JSON.stringify(before) === JSON.stringify(f.counts()) + }; + } finally { + f.close(); + } + }); + expect(settled).toEqual({ + status: 'stopped', + slot: { state: 'idle' }, + unchanged: true + }); + }); diff --git a/web/tests/e2e/seal-builder.spec.ts b/web/tests/e2e/seal-builder.spec.ts @@ -109,7 +109,7 @@ for (const role of ['peer', 'self'] as const) randomizedBounds: true, signs: 1, encrypts: 1, - keys: 3, + keys: 4, again: 'stopped' }); expect(result.target).toBe(result.expected); @@ -180,7 +180,7 @@ test('detached reservation, wrong role or absent explicit review cannot acquire }); expect(result).toEqual({ absent: true, same: true }); }); -for (const phase of ['hold_encrypt', 'hold_sign'] as const) +for (const phase of ['hold_encrypt', 'hold_decrypt', 'hold_sign'] as const) test(`disconnect during ${phase} retains real slot until settlement and fences late result`, async ({ page }) => { @@ -197,7 +197,12 @@ for (const phase of ['hold_encrypt', 'hold_sign'] as const) .poll(() => page.evaluate(() => window.hcp075Fixture.slot())) .toMatchObject({ state: 'active', - pending: phase === 'hold_encrypt' ? 'encrypt' : 'sign' + pending: + phase === 'hold_encrypt' + ? 'encrypt' + : phase === 'hold_decrypt' + ? 'decrypt' + : 'sign' }); const pending = await page.evaluate(() => { const f = window.hcp075Fixture; diff --git a/web/tests/provenance/source-boundaries.test.mjs b/web/tests/provenance/source-boundaries.test.mjs @@ -2101,7 +2101,8 @@ test('history scroll owner rejects malformed values without coercion or SSR effe test( 'HCP076 allows only the byte-pinned disposable gift-wrap producer and rejects key escape or copied construction', - { timeout: 30000 }, + // Nine sequential audits retain8s each, plus bounded real fixture setup. + { timeout: 90000 }, async () => { await fixture(async ({ directory, put, execute }) => { await confineSvelte(directory); @@ -2131,6 +2132,7 @@ test( for (const alteration of [ source + '\nexport const secret = generateSecretKey();', source.replace('secret?.fill(0);', '// cleanup removed'), + source.replace('nip44.v2.decrypt(', 'nip44.v2.encrypt('), source.replace('kind: 1059,', 'kind: 14,'), source.replace( "tags: [['p', record.destination]],", @@ -2142,6 +2144,7 @@ test( ), source.replace("'applesauce-core/helpers'", "'nostr-tools/pure'") ]) { + assert.notEqual(alteration, source); await put(name, alteration); reject(execute(), /gift-wrap construction source identity/); } diff --git a/web/tests/unit/giftwrap-builder.test.ts b/web/tests/unit/giftwrap-builder.test.ts @@ -258,3 +258,23 @@ for (const response of ['wrong_target', 'cached_bad_id'] as const) expect(state.conversations[0].every((x) => x === 0)).toBe(true); f.key.fill(0); }); +for (const fault of ['mismatch', 'exception'] as const) + it(`outer roundtrip ${fault} clears directly owned buffers and grants no wrapper`, () => { + vi.stubGlobal('window', {}); + const f = fixture(); + const spy = vi.spyOn(nip44.v2, 'decrypt').mockImplementation(() => { + if (fault === 'exception') throw Error('SDK roundtrip fault'); + return 'substitute signed seal'; + }); + try { + expect( + buildPrivateGiftwrap(f.seal, 'reviewed_private_wrap') + ).toBeUndefined(); + expect(state.keys).toHaveLength(1); + expect(state.keys[0].every((x) => x === 0)).toBe(true); + expect(state.conversations[0].every((x) => x === 0)).toBe(true); + } finally { + spy.mockRestore(); + f.key.fill(0); + } + }); diff --git a/web/tools/source-boundaries.mjs b/web/tools/source-boundaries.mjs @@ -1555,7 +1555,7 @@ export async function auditSource(root) { const giftwrapTrusted = files.has(giftwrapFile) && createHash('sha256').update(files.get(giftwrapFile)).digest('hex') === - '7f22b02cc21bb2cfaca4d984ea3fe94ed92420aad8235901d1819880396fe245'; + '866d53d993f40edc15828fcf279c03b35258cc3e5de8f555ac95339f846ac9f3'; if (files.has(giftwrapFile) && !giftwrapTrusted) complain( giftwrapFile,