app

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

commit 81142cb775c0e4b2d48033a238e979793824d59a
parent c308a5f7d60dfae874957da9dc60327f61dafc0d
Author: triesap <tyson@radroots.org>
Date:   Wed,  7 Oct 2026 17:51:39 +0000

messages: build recipient-encrypted sender-signed seals (HCP-075)

- Bind seal preparation to genuine current owner and reserved rumor
- Serialize reviewed encryption and signing through existing ownership ports
- Verify immutable signed fields independently of provider cache markers
- Exercise bounded admission and pending-call lifecycle in real Chromium

Diffstat:
Aweb/src/lib/nostr/seal-builder.ts | 273+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/src/lib/nostr/seal-template.ts | 104+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/harness/seal-builder.ts | 290+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/seal-builder.spec.ts | 388+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/seal-builder.test.ts | 136+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5 files changed, 1191 insertions(+), 0 deletions(-)

diff --git a/web/src/lib/nostr/seal-builder.ts b/web/src/lib/nostr/seal-builder.ts @@ -0,0 +1,273 @@ +import { ExtensionSigner } from 'applesauce-signers'; +import type { UnsignedEvent } from 'applesauce-core/helpers'; +import { + reservedSendSnapshot, + reservedSendRumorWire, + type ReservedSendIdentity +} from '../messaging/send-identity.ts'; +import { + identityMessagingOwnership, + disconnectIdentity, + type IdentitySession +} from '../runtime/identity-session.ts'; +import { + browserExtensionScheduler, + runExtensionAction, + callExtension, + stopExtensionAction, + markExtensionWaitExpired, + type ExtensionAction +} from './extension-scheduler.ts'; +import { safeUnsignedInteger } from './envelope-bounds.ts'; +import { + sealCiphertextV2, + captureSealTemplate, + bindSealResponse +} from './seal-template.ts'; +declare const operationBrand: unique symbol; +declare const sealBrand: unique symbol; +export type PrivateSealOperation = Readonly<{ [operationBrand]: true }>; +export type PrivateRecipientSeal = Readonly<{ [sealBrand]: true }>; +export type PrivateSealResult = + | Readonly<{ status: 'sealed'; seal: PrivateRecipientSeal }> + | Readonly<{ + status: + 'invalid' | 'busy' | 'unavailable' | 'refused' | 'stopped' | 'mismatch'; + }>; +type State = { + run(): Promise<PrivateSealResult>; + stop(expired: boolean): void; +}; +type SavedSeal = Readonly<{ + owner: string; + peer: string; + destination: string; + role: 'peer' | 'self'; + command: string; + rumorHash: string; + wire: string; + current(): boolean; +}>; +const operations = new WeakMap<PrivateSealOperation, State>(); +const seals = new WeakMap<PrivateRecipientSeal, SavedSeal>(); +// Explicit lower-level crypto preparation, not inbox readiness, durable CAS, +// saved-encrypted evidence, a Send controller or a public/private publisher. +export function capturePrivateSealOperation( + session: IdentitySession, + reserved: ReservedSendIdentity, + role: unknown, + review: unknown +): PrivateSealOperation | undefined { + if ( + review !== 'reviewed_private_seal' || + (role !== 'peer' && role !== 'self') + ) + return undefined; + const inputRecord = reservedSendSnapshot(reserved), + inputOwnership = identityMessagingOwnership(session); + if ( + !inputRecord || + !inputOwnership || + inputRecord.owner !== inputOwnership.owner || + !inputOwnership.current() + ) + return undefined; + const record = inputRecord, + ownership = inputOwnership, + capturedRole = role; + const target = capturedRole === 'self' ? record.owner : record.peer; + let stopped = false, + started = false, + active: ExtensionAction | undefined; + const current = () => { + const observed = reservedSendSnapshot(reserved); + return ( + !stopped && + ownership.current() && + observed?.owner === record.owner && + observed.id === record.id && + observed.peer === record.peer && + observed.rumorHash === record.rumorHash + ); + }; + function stop(expired: boolean) { + stopped = true; + if (active) { + if (expired) markExtensionWaitExpired(active); + else stopExtensionAction(active); + } + } + function cipherPort() { + try { + if (!current()) return undefined; + const cipher = new ExtensionSigner().nip44; + if (!current() || !cipher) return undefined; + const encryptMethod = cipher.encrypt; + if (!current()) return undefined; + const decryptMethod = cipher.decrypt; + if ( + !current() || + typeof encryptMethod !== 'function' || + typeof decryptMethod !== 'function' + ) + return undefined; + const encrypt = encryptMethod.bind(cipher); + if (!current()) return undefined; + const decrypt = decryptMethod.bind(cipher); + if (!current()) return undefined; + // Owned plain port: the provider's getters are never re-read inside a + // scheduled invocation with the captured private rumor. + return { encrypt, decrypt }; + } catch { + return undefined; + } + } + async function fresh(action: ExtensionAction): Promise<boolean> { + 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 !== record.owner + ) { + disconnectIdentity(session); + return false; + } + const cipher = cipherPort(); + if (!current()) return false; + if (!cipher) { + disconnectIdentity(session); + return false; + } + return current(); + } + async function work(action: ExtensionAction): Promise<PrivateSealResult> { + active = action; + const initial = cipherPort(); + if (!current()) return { status: 'stopped' }; + if (!initial) { + disconnectIdentity(session); + return { status: 'unavailable' }; + } + if (!(await fresh(action))) return { status: 'stopped' }; + const wire = reservedSendRumorWire(reserved), + cipher = cipherPort(); + if (!cipher && current()) disconnectIdentity(session); + if (!wire || !cipher || !current()) return { status: 'stopped' }; + const encrypted = await callExtension(action, 'encrypt', () => + cipher.encrypt(target, wire) + ); + if (!current()) return { status: 'stopped' }; + if (encrypted.status !== 'settled' || !encrypted.current) + return { status: encrypted.status === 'denied' ? 'refused' : 'stopped' }; + if (!sealCiphertextV2(encrypted.value)) 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 + // timestamp. No identity key, crypto implementation or future time created. + const random = crypto.getRandomValues(new Uint32Array(1))[0], + now = Math.floor(milliseconds / 1000), + time = Math.max(0, now - (random % 3600)); + const captured = captureSealTemplate(record.owner, encrypted.value, time); + if (!captured || !current()) return { status: 'mismatch' }; + const response = await callExtension(action, 'sign', () => + new ExtensionSigner().signEvent(JSON.parse(captured) as UnsignedEvent) + ); + if (!current()) return { status: 'stopped' }; + if (response.status !== 'settled' || !response.current) + return { status: response.status === 'denied' ? 'refused' : 'stopped' }; + const signed = bindSealResponse(captured, response.value); + if (!signed) return { status: 'mismatch' }; + if (!(await fresh(action))) return { status: 'stopped' }; + if (!current()) return { status: 'stopped' }; + const seal = Object.freeze({}) as PrivateRecipientSeal; + seals.set(seal, { + owner: record.owner, + peer: record.peer, + destination: target, + role: capturedRole, + command: record.id, + rumorHash: record.rumorHash, + wire: signed, + current + }); + return { status: 'sealed', seal }; + } + async function run(): Promise<PrivateSealResult> { + if (started || !current()) return { status: 'stopped' }; + started = true; + if (typeof window === 'undefined' || !navigator.locks?.request) + return { status: 'unavailable' }; + try { + return await navigator.locks.request( + 'harvestcircle:owner:' + record.owner, + { mode: 'exclusive', ifAvailable: true }, + async (lock): Promise<PrivateSealResult> => { + if (!lock) return { status: 'busy' }; + if (!current()) return { status: 'stopped' }; + const scheduler = browserExtensionScheduler(); + if (!scheduler) return { status: 'unavailable' }; + const result = await runExtensionAction( + scheduler, + { + owner: record.owner, + session: ownership.session, + operation: Symbol() + }, + current, + work + ); + 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() ? 'refused' : 'stopped' }; + } finally { + active = undefined; + } + } + const operation = Object.freeze({}) as PrivateSealOperation; + operations.set(operation, { run, stop }); + return operation; +} +export function buildPrivateSeal( + operation: PrivateSealOperation +): Promise<PrivateSealResult> { + return ( + operations.get(operation)?.run() ?? Promise.resolve({ status: 'invalid' }) + ); +} +export function stopPrivateSeal(operation: PrivateSealOperation): void { + operations.get(operation)?.stop(false); +} +export function expirePrivateSealWait(operation: PrivateSealOperation): void { + operations.get(operation)?.stop(true); +} +// Detached signed ciphertext only; a cast/copy is not a private seal token. +// Future wrapper/nested owners must retain exact original operation binding. +export function privateSealSnapshot( + seal: PrivateRecipientSeal +): Readonly<Omit<SavedSeal, 'current'>> | undefined { + const saved = seals.get(seal); + return saved?.current() + ? { + owner: saved.owner, + peer: saved.peer, + destination: saved.destination, + role: saved.role, + command: saved.command, + rumorHash: saved.rumorHash, + wire: saved.wire + } + : undefined; +} diff --git a/web/src/lib/nostr/seal-template.ts b/web/src/lib/nostr/seal-template.ts @@ -0,0 +1,104 @@ +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 { safeUnsignedInteger } from './envelope-bounds.ts'; +import { verifyEnvelope } from './verified-envelope.ts'; +// Encoded version/size preflight only. Authentication/decryption is owned by +// the SDK and later nested validation, never inferred from base64 structure. +export function sealCiphertextV2(value: unknown): value is string { + if ( + typeof value !== 'string' || + value.length < 132 || + !boundedUtf8(value, 16384) || + !/^[A-Za-z0-9+/]+={0,2}$/.test(value) + ) + return false; + try { + const decoded = atob(value); + return ( + decoded.length >= 99 && + decoded.charCodeAt(0) === 2 && + btoa(decoded) === value + ); + } catch { + return false; + } +} +// Detached pure data, not an operation/signing/publication capability. +export function captureSealTemplate( + author: unknown, + ciphertext: unknown, + timestamp: unknown +): string | undefined { + const owner = canonicalPublicKey(author), + time = safeUnsignedInteger(timestamp); + if (!owner || time === undefined || !sealCiphertextV2(ciphertext)) + return undefined; + const wire = JSON.stringify({ + pubkey: owner, + kind: 13, + created_at: time, + tags: [], + content: ciphertext + }); + return boundedUtf8(wire, 16384) ? wire : undefined; +} +function own(value: object, name: string): unknown { + const property = Object.getOwnPropertyDescriptor(value, name); + return property && 'value' in property ? property.value : undefined; +} +// Reconstruct only fixed own data fields. No raw spread, getters, toJSON, +// iterators, extra fields or SDK cache symbols enter the retained private wire. +export function bindSealResponse( + captured: unknown, + response: unknown +): string | undefined { + try { + if ( + typeof captured !== 'string' || + !boundedUtf8(captured, 16384) || + typeof response !== 'object' || + response === null || + Array.isArray(response) + ) + return undefined; + const template = JSON.parse(captured) as UnsignedEvent; + if ( + captureSealTemplate( + template.pubkey, + template.content, + template.created_at + ) !== captured + ) + return undefined; + for (const name of ['pubkey', 'kind', 'created_at', 'content'] as const) + if (own(response, name) !== template[name]) return undefined; + const tags = own(response, 'tags'), + id = own(response, 'id'), + sig = own(response, 'sig'); + if ( + !Array.isArray(tags) || + own(tags, 'length') !== 0 || + typeof id !== 'string' || + !/^[0-9a-f]{64}$/.test(id) || + typeof sig !== 'string' || + !/^[0-9a-f]{128}$/.test(sig) || + id !== getEventHash(template) + ) + return undefined; + const wire = JSON.stringify({ + pubkey: template.pubkey, + kind: 13, + created_at: template.created_at, + tags: [], + content: template.content, + id, + sig + }); + return boundedUtf8(wire, 16384) && verifyEnvelope(wire).ok + ? wire + : undefined; + } catch { + return undefined; + } +} diff --git a/web/tests/e2e/harness/seal-builder.ts b/web/tests/e2e/harness/seal-builder.ts @@ -0,0 +1,290 @@ +import { + finalizeEvent, + generateSecretKey, + getPublicKey, + verifiedSymbol, + type UnsignedEvent +} from 'applesauce-core/helpers'; +import { nip44 } from 'applesauce-core/helpers/encryption'; +import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts'; +import { captureEnquiryContext } from '../../../src/lib/messaging/enquiry-context.ts'; +import { captureEnquiryRumor } from '../../../src/lib/messaging/rumor-plan.ts'; +import { + openBrowserDatabase, + closeBrowserDatabase, + browserDatabaseTransaction +} from '../../../src/lib/persistence/database.ts'; +import { createPrivateSendReservationRepository } from '../../../src/lib/persistence/private-send-reservations.ts'; +import { + reserveSendIdentity, + reservedSendRumorWire +} from '../../../src/lib/messaging/send-identity.ts'; +import { + createIdentitySession, + connectIdentity, + probeIdentityMessaging, + identitySessionSnapshot, + disconnectIdentity +} from '../../../src/lib/runtime/identity-session.ts'; +import { + capturePrivateSealOperation, + buildPrivateSeal, + stopPrivateSeal, + expirePrivateSealWait, + privateSealSnapshot +} from '../../../src/lib/nostr/seal-builder.ts'; +import { + browserExtensionScheduler, + extensionSchedulerSnapshot +} from '../../../src/lib/nostr/extension-scheduler.ts'; +export { + capturePrivateSealOperation, + buildPrivateSeal, + stopPrivateSeal, + expirePrivateSealWait, + privateSealSnapshot +}; +export type Mode = + | 'normal' + | 'wrong_cipher' + | 'wrong_author' + | 'wrong_tags' + | 'wrong_time' + | 'cached_bad_id' + | 'missing' + | 'declined' + | 'changed_key' + | 'hold_encrypt' + | 'hold_sign' + | 'getter_reentry' + | 'stop_capability_getter' + | 'stop_capability_after_key'; +// Ephemeral source-only provider: actual stock SDK encryption/signature and real +// Chromium IDB/WebLocks. No installed extension/relay/client qualification. +export async function makeFixture() { + const secret = generateSecretKey(), + peerSecret = generateSecretKey(), + owner = getPublicKey(secret), + peer = getPublicKey(peerSecret); + let mode: Mode = 'normal', + keys = 0, + encrypts = 0, + signs = 0, + capabilityReads = 0, + reentrantReads = 0, + postStopEncrypts = 0, + getterStopped = false, + watched: ReturnType<typeof capturePrivateSealOperation>, + release: (() => void) | undefined; + function encryptTo(target: string, text: string) { + const conversation = nip44.v2.utils.getConversationKey(secret, target); + try { + return nip44.v2.encrypt(text, conversation); + } finally { + conversation.fill(0); + } + } + function sign(template: UnsignedEvent) { + const input = + mode === 'wrong_cipher' + ? { ...template, content: encryptTo(peer, 'different immutable rumor') } + : mode === 'wrong_tags' + ? { ...template, tags: [['client', 'leak']] } + : mode === 'wrong_time' + ? { ...template, created_at: template.created_at + 1 } + : template; + const signed = finalizeEvent( + input, + mode === 'wrong_author' ? peerSecret : secret + ); + return mode === 'cached_bad_id' + ? { ...signed, id: '0'.repeat(64), [verifiedSymbol]: true } + : { + ...signed, + plaintext: 'never retained sentinel', + toJSON: () => { + throw Error('unexpected provider conversion'); + } + }; + } + const provider = { + getPublicKey: () => { + keys++; + return Promise.resolve(mode === 'changed_key' ? peer : owner); + }, + signEvent: (template: UnsignedEvent) => { + signs++; + return mode === 'hold_sign' + ? new Promise<ReturnType<typeof sign>>((resolve) => { + release = () => resolve(sign(template)); + }) + : Promise.resolve(sign(template)); + }, + get nip44() { + capabilityReads++; + if ( + watched && + (mode === 'stop_capability_getter' || + (mode === 'stop_capability_after_key' && capabilityReads === 2)) + ) { + stopPrivateSeal(watched); + return undefined; + } + return mode === 'missing' + ? undefined + : { + get encrypt() { + const scheduler = browserExtensionScheduler(), + slot = scheduler && extensionSchedulerSnapshot(scheduler); + if ( + mode === 'getter_reentry' && + watched && + slot && + slot.state === 'active' && + slot.pending === 'encrypt' + ) { + reentrantReads++; + getterStopped = true; + stopPrivateSeal(watched); + } + return (target: string, text: string) => { + encrypts++; + if (getterStopped) postStopEncrypts++; + if (mode === 'declined') + return Promise.reject(Error('private failure must not leak')); + if (mode === 'hold_encrypt') + return new Promise<string>((resolve) => { + release = () => resolve(encryptTo(target, text)); + }); + return Promise.resolve(encryptTo(target, 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); + } + } + }; + } + }; + Object.defineProperty(window, 'nostr', { + configurable: true, + value: provider + }); + const identity = createIdentitySession(); + await connectIdentity(identity); + await probeIdentityMessaging(identity, 'reviewed_self_copy'); + const food = finalizeEvent( + { + kind: 30402, + created_at: 1700000060, + content: 'Public carrots', + tags: [ + ['d', 'carrots'], + ['title', 'Carrots'], + ['summary', 'Fresh carrots'], + ['published_at', '1700000000'], + ['location', 'Victoria'], + ['price', '3.5', 'CAD'], + ['radroots:price_unit', 'lb'], + ['status', 'active'] + ] + }, + peerSecret + ); + const proof = verifyEnvelope(JSON.stringify(food)); + if (!proof.ok) throw Error('invalid public fixture'); + const context = captureEnquiryContext(proof.value); + if (!context) throw Error('invalid context'); + const plan = captureEnquiryRumor( + identity, + context, + 'Private seal sentinel', + Math.floor(Date.now() / 1000) + ); + if (!plan) throw Error('missing plan'); + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') throw Error('missing database'); + 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'); + const reserved = reservation.identity; + const original = reservedSendRumorWire(reserved); + return { + owner, + peer, + identity, + reserved, + operation: ( + role: unknown = 'peer', + review: unknown = 'reviewed_private_seal' + ) => { + watched = capturePrivateSealOperation(identity, reserved, role, review); + return watched; + }, + mode: (value: Mode) => { + mode = value; + capabilityReads = 0; + }, + counts: () => ({ keys, encrypts, signs, reentrantReads, postStopEncrypts }), + identityState: () => identitySessionSnapshot(identity).state, + settle: () => { + release?.(); + }, + slot: () => { + const scheduler = browserExtensionScheduler(); + return scheduler ? extensionSchedulerSnapshot(scheduler) : undefined; + }, + disconnect: () => disconnectIdentity(identity), + async stored() { + const tx = browserDatabaseTransaction( + database, + ['private_sends'], + 'readonly' + ), + request = tx.objectStore('private_sends').getAll(); + return await new Promise<string>((resolve, reject) => { + tx.addEventListener('complete', () => + resolve(JSON.stringify(request.result)) + ); + tx.addEventListener('abort', () => reject(Error('inspection aborted'))); + }); + }, + decrypt(wire: string, role: 'peer' | 'self') { + const seal = JSON.parse(wire) as { content: string }; + const conversation = nip44.v2.utils.getConversationKey( + role === 'peer' ? peerSecret : secret, + owner + ); + try { + return { + equal: nip44.v2.decrypt(seal.content, conversation) === original, + seal + }; + } finally { + conversation.fill(0); + } + }, + close() { + disconnectIdentity(identity); + closeBrowserDatabase(database); + secret.fill(0); + peerSecret.fill(0); + delete window.nostr; + } + }; +} diff --git a/web/tests/e2e/seal-builder.spec.ts b/web/tests/e2e/seal-builder.spec.ts @@ -0,0 +1,388 @@ +import { expect, test, type Page } from '@playwright/test'; +import { build } from 'vite'; +import { fileURLToPath } from 'node:url'; +import { createHash } from 'node:crypto'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Seals from './harness/seal-builder.ts'; +declare global { + interface Window { + hcp075: typeof Seals; + hcp075Fixture: Awaited<ReturnType<typeof Seals.makeFixture>>; + hcp075Job: ReturnType<typeof Seals.buildPrivateSeal>; + hcp075Release: () => void; + hcp075Held: Promise<unknown>; + hcp075Operation: NonNullable< + ReturnType<typeof Seals.capturePrivateSealOperation> + >; + } +} +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/seal-builder.ts', import.meta.url) + ), + name: 'hcp075', + 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; + console.log( + JSON.stringify({ + fixture: 'HCP075_ACTUAL_SDK_CRYPTO_IDB_OWNER_LOCK', + bundleSha256: createHash('sha256').update(bundle).digest('hex'), + moduleIds: Object.keys(chunks[0].modules), + qualification: + 'Ephemeral controlled provider; not installed extension/relay/client Q' + }) + ); +}); +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.hcp075Fixture = await window.hcp075.makeFixture(); + }); +} +for (const role of ['peer', 'self'] as const) + test(`actual SDK ${role} ciphertext preserves original rumor; sender signs empty-tag13 only`, async ({ + page + }) => { + await load(page); + const result = await page.evaluate(async (role) => { + const f = window.hcp075Fixture, + s = window.hcp075, + before = f.counts(), + operation = f.operation(role); + if (!operation) throw Error('missing operation'); + const outcome = await s.buildPrivateSeal(operation); + if (outcome.status !== 'sealed') return { status: outcome.status }; + const saved = s.privateSealSnapshot(outcome.seal); + if (!saved) throw Error('missing seal'); + const decrypted = f.decrypt(saved.wire, role), + stored = await f.stored(), + after = f.counts(), + again = await s.buildPrivateSeal(operation); + f.close(); + return { + status: outcome.status, + equal: decrypted.equal, + kind: (JSON.parse(saved.wire) as { kind: number }).kind, + tags: (JSON.parse(saved.wire) as { tags: string[][] }).tags, + owner: saved.owner, + target: saved.destination, + expected: role === 'self' ? f.owner : f.peer, + seven: Object.keys(JSON.parse(saved.wire) as Record<string, unknown>) + .length, + noPlaintext: !stored.includes('sentinel'), + randomizedBounds: + (JSON.parse(saved.wire) as { created_at: number }).created_at <= + Math.floor(Date.now() / 1000) && + (JSON.parse(saved.wire) as { created_at: number }).created_at >= + Math.floor(Date.now() / 1000) - 3599, + signs: after.signs - before.signs, + encrypts: after.encrypts - before.encrypts, + keys: after.keys - before.keys, + again: again.status + }; + }, role); + expect(result).toMatchObject({ + status: 'sealed', + equal: true, + kind: 13, + tags: [], + seven: 7, + noPlaintext: true, + randomizedBounds: true, + signs: 1, + encrypts: 1, + keys: 3, + again: 'stopped' + }); + expect(result.target).toBe(result.expected); + }); +for (const mode of [ + 'wrong_cipher', + 'wrong_author', + 'wrong_tags', + 'wrong_time', + 'cached_bad_id' +] as const) + test(`rejects ${mode} from provider without a seal capability`, async ({ + page + }) => { + await load(page); + const result = await page.evaluate(async (mode) => { + const f = window.hcp075Fixture, + op = f.operation(); + if (!op) throw Error('missing operation'); + f.mode(mode); + const outcome = await window.hcp075.buildPrivateSeal(op); + f.close(); + return outcome.status; + }, mode); + expect(result).toBe('mismatch'); + }); +for (const mode of ['missing', 'declined', 'changed_key'] as const) + test(`${mode} pauses without extra signature or retry`, async ({ page }) => { + await load(page); + const result = await page.evaluate(async (mode) => { + const f = window.hcp075Fixture, + op = f.operation(), + before = f.counts(); + if (!op) throw Error('missing operation'); + f.mode(mode); + const result = await window.hcp075.buildPrivateSeal(op), + after = f.counts(); + f.close(); + return { status: result.status, signs: after.signs - before.signs }; + }, mode); + expect(['unavailable', 'refused', 'stopped']).toContain(result.status); + expect(result.signs).toBe(0); + }); +test('detached reservation, wrong role or absent explicit review cannot acquire crypto authority', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(() => { + const f = window.hcp075Fixture, + s = window.hcp075, + before = f.counts(); + const invalid = [ + f.operation('other'), + f.operation('peer', 'connect'), + s.capturePrivateSealOperation( + f.identity, + {} as typeof f.reserved, + 'peer', + 'reviewed_private_seal' + ) + ]; + const after = f.counts(); + f.close(); + return { + absent: invalid.every((x) => x === undefined), + same: JSON.stringify(before) === JSON.stringify(after) + }; + }); + expect(result).toEqual({ absent: true, same: true }); +}); +for (const phase of ['hold_encrypt', 'hold_sign'] as const) + test(`disconnect during ${phase} retains real slot until settlement and fences late result`, async ({ + page + }) => { + await load(page); + await page.evaluate((phase) => { + const f = window.hcp075Fixture, + op = f.operation(); + if (!op) throw Error('missing operation'); + window.hcp075Operation = op; + f.mode(phase); + window.hcp075Job = window.hcp075.buildPrivateSeal(op); + }, phase); + await expect + .poll(() => page.evaluate(() => window.hcp075Fixture.slot())) + .toMatchObject({ + state: 'active', + pending: phase === 'hold_encrypt' ? 'encrypt' : 'sign' + }); + const pending = await page.evaluate(() => { + const f = window.hcp075Fixture; + f.disconnect(); + window.hcp075.stopPrivateSeal(window.hcp075Operation); + return f.slot(); + }); + expect(pending).toMatchObject({ state: 'active' }); + const result = await page.evaluate(async () => { + const f = window.hcp075Fixture, + before = f.counts(); + f.settle(); + const outcome = await window.hcp075Job, + after = f.counts(), + slot = f.slot(); + f.close(); + return { + status: outcome.status, + slot, + same: JSON.stringify(before) === JSON.stringify(after) + }; + }); + expect(result).toEqual({ + status: 'stopped', + slot: { state: 'idle' }, + same: true + }); + }); +test('wait expiry prevents more calls but does not pretend to cancel pending extension approval', async ({ + page +}) => { + await load(page); + await page.evaluate(() => { + const f = window.hcp075Fixture, + op = f.operation(); + if (!op) throw Error('missing operation'); + f.mode('hold_encrypt'); + window.hcp075Operation = op; + window.hcp075Job = window.hcp075.buildPrivateSeal(op); + }); + await expect + .poll(() => page.evaluate(() => window.hcp075Fixture.slot())) + .toMatchObject({ pending: 'encrypt' }); + const result = await page.evaluate(async () => { + const f = window.hcp075Fixture, + s = window.hcp075; + s.expirePrivateSealWait(window.hcp075Operation); + const pending = f.slot(); + f.settle(); + const outcome = await window.hcp075Job, + slot = f.slot(); + f.close(); + return { pending, status: outcome.status, slot }; + }); + expect(result.pending).toMatchObject({ + state: 'active', + pending: 'encrypt', + phase: 'wait_expired' + }); + expect(result.status).toBe('stopped'); + expect(result.slot).toEqual({ state: 'idle' }); +}); +test('held origin owner lock fails busy before any extension call and never queues a retry', async ({ + page +}) => { + await load(page); + await page.evaluate(async () => { + let acquired: () => void = () => {}; + const ready = new Promise<void>((resolve) => { + acquired = resolve; + }); + window.hcp075Held = navigator.locks.request( + 'harvestcircle:owner:' + window.hcp075Fixture.owner, + async () => { + acquired(); + await new Promise<void>((resolve) => { + window.hcp075Release = resolve; + }); + } + ); + await ready; + }); + const result = await page.evaluate(async () => { + const f = window.hcp075Fixture, + op = f.operation(), + before = f.counts(); + if (!op) throw Error('missing operation'); + const outcome = await window.hcp075.buildPrivateSeal(op), + after = f.counts(); + window.hcp075Release(); + await window.hcp075Held; + const again = await window.hcp075.buildPrivateSeal(op); + f.close(); + return { + status: outcome.status, + same: JSON.stringify(before) === JSON.stringify(after), + again: again.status + }; + }); + expect(result).toEqual({ status: 'busy', same: true, again: 'stopped' }); +}); +test('second peer/self operation cannot overlap the held scheduler/owner scope', async ({ + page +}) => { + await load(page); + await page.evaluate(() => { + const f = window.hcp075Fixture, + op = f.operation('self'); + if (!op) throw Error('missing operation'); + f.mode('hold_encrypt'); + window.hcp075Operation = op; + window.hcp075Job = window.hcp075.buildPrivateSeal(op); + }); + await expect + .poll(() => page.evaluate(() => window.hcp075Fixture.slot())) + .toMatchObject({ state: 'active', pending: 'encrypt' }); + const result = await page.evaluate(async () => { + const f = window.hcp075Fixture, + s = window.hcp075, + second = f.operation('peer'), + before = f.counts(); + if (!second) throw Error('missing second operation'); + const blocked = await s.buildPrivateSeal(second), + after = f.counts(); + s.stopPrivateSeal(window.hcp075Operation); + f.settle(); + const original = await window.hcp075Job; + f.close(); + return { + blocked: blocked.status, + same: JSON.stringify(before) === JSON.stringify(after), + original: original.status + }; + }); + expect(result).toEqual({ blocked: 'busy', same: true, original: 'stopped' }); +}); +test('provider method getter is captured before scheduler encryption admission, never re-read with private input', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp075Fixture, + op = f.operation(); + if (!op) throw Error('missing operation'); + f.mode('getter_reentry'); + const outcome = await window.hcp075.buildPrivateSeal(op), + counts = f.counts(); + f.close(); + return { + status: outcome.status, + reentrant: counts.reentrantReads, + postStop: counts.postStopEncrypts + }; + }); + expect(result).toEqual({ status: 'sealed', reentrant: 0, postStop: 0 }); +}); +for (const mode of [ + 'stop_capability_getter', + 'stop_capability_after_key' +] as const) + test(`${mode} stops only the original operation and preserves the current shared identity`, async ({ + page + }) => { + await load(page); + const result = await page.evaluate(async (mode) => { + const f = window.hcp075Fixture, + op = f.operation(), + before = f.counts(); + if (!op) throw Error('missing operation'); + f.mode(mode); + const outcome = await window.hcp075.buildPrivateSeal(op), + state = f.identityState(), + after = f.counts(); + f.close(); + return { + status: outcome.status, + state, + signs: after.signs - before.signs, + encrypts: after.encrypts - before.encrypts + }; + }, mode); + expect(result).toEqual({ + status: 'stopped', + state: 'messaging_capable', + signs: 0, + encrypts: 0 + }); + }); diff --git a/web/tests/unit/seal-builder.test.ts b/web/tests/unit/seal-builder.test.ts @@ -0,0 +1,136 @@ +import { afterAll, expect, it } from 'vitest'; +import { + finalizeEvent, + generateSecretKey, + getPublicKey, + verifiedSymbol, + type UnsignedEvent +} from 'applesauce-core/helpers'; +import { + sealCiphertextV2, + captureSealTemplate, + bindSealResponse +} from '../../src/lib/nostr/seal-template.ts'; +import { isPublicEnvelopeKind } from '../../src/lib/nostr/public-kinds.ts'; +const key = generateSecretKey(); +const owner = getPublicKey(key); +afterAll(() => key.fill(0)); +const cipher = btoa(String.fromCharCode(2) + 'x'.repeat(98)); +function fixture() { + const wire = captureSealTemplate(owner, cipher, 1700000000); + if (!wire) throw Error('expected source seal template'); + return { wire, template: JSON.parse(wire) as UnsignedEvent }; +} +it('captures only encrypted kind13 with exact sender/time and empty tags; public lane excludes it', () => { + const { template } = fixture(); + expect(template).toEqual({ + pubkey: owner, + kind: 13, + created_at: 1700000000, + tags: [], + content: cipher + }); + expect(isPublicEnvelopeKind(13)).toBe(false); + expect(isPublicEnvelopeKind(14)).toBe(false); +}); +it('requires bounded canonical v2 encoded payload and exact numeric/owner inputs', () => { + expect(sealCiphertextV2(cipher)).toBe(true); + for (const bad of [ + null, + '', + 'plain text', + '#version', + cipher + '\n', + btoa(String.fromCharCode(1) + 'x'.repeat(98)), + 'A'.repeat(16385) + ]) + expect(sealCiphertextV2(bad)).toBe(false); + for (const bad of [-0, -1, 1.5, Number.MAX_SAFE_INTEGER + 1, '100']) + expect(captureSealTemplate(owner, cipher, bad)).toBeUndefined(); + expect(captureSealTemplate(owner.toUpperCase(), cipher, 1)).toBeUndefined(); +}); +it('accepts genuine signatures while reconstructing only seven allowed signed fields', () => { + const { wire, template } = fixture(); + const signed = finalizeEvent(template, key); + const result = bindSealResponse(wire, { + ...signed, + plaintext: 'private sentinel', + toJSON: () => { + throw Error('must not execute'); + } + }); + expect(result).toBeDefined(); + expect( + Object.keys(JSON.parse(result!) as Record<string, unknown>).sort() + ).toEqual(['content', 'created_at', 'id', 'kind', 'pubkey', 'sig', 'tags']); + expect(result).not.toContain('sentinel'); +}); +it('rejects valid signatures for substituted ciphertext, kind, tags, time or sender', () => { + const { wire, template } = fixture(); + for (const changed of [ + { ...template, content: btoa(String.fromCharCode(2) + 'y'.repeat(98)) }, + { ...template, kind: 1059 }, + { ...template, tags: [['p', owner]] }, + { ...template, created_at: 1700000001 } + ]) + expect(bindSealResponse(wire, finalizeEvent(changed, key))).toBeUndefined(); + const other = generateSecretKey(); + try { + expect( + bindSealResponse(wire, finalizeEvent(template, other)) + ).toBeUndefined(); + } finally { + other.fill(0); + } +}); +it('freshly verifies hash and signature despite provider cache symbols', () => { + const { wire, template } = fixture(); + const signed = finalizeEvent(template, key); + expect( + bindSealResponse(wire, { + ...signed, + id: '0'.repeat(64), + [verifiedSymbol]: true + }) + ).toBeUndefined(); + expect( + bindSealResponse(wire, { + ...signed, + sig: '0'.repeat(128), + [verifiedSymbol]: true + }) + ).toBeUndefined(); +}); +it('own data fields only: getters/toJSON/iterators cannot supply accepted fields', () => { + const { wire, template } = fixture(); + const signed = finalizeEvent(template, key); + let reads = 0; + const response = { ...signed }; + Object.defineProperty(response, 'content', { + get() { + reads++; + return cipher; + } + }); + expect(bindSealResponse(wire, response)).toBeUndefined(); + expect(reads).toBe(0); + const tags: string[] = []; + Object.defineProperty(tags, Symbol.iterator, { + value: () => { + throw Error('must not enumerate'); + } + }); + expect(bindSealResponse(wire, { ...signed, tags })).toBeDefined(); +}); +it('malformed templates/objects and nonempty provider tags never become private seals', () => { + const { wire, template } = fixture(); + for (const bad of [null, [], {}, '{', ' '.repeat(16385)]) + expect(bindSealResponse(wire, bad)).toBeUndefined(); + expect(bindSealResponse('{}', finalizeEvent(template, key))).toBeUndefined(); + expect( + bindSealResponse(wire, { + ...finalizeEvent(template, key), + tags: [['client', 'leak']] + }) + ).toBeUndefined(); +});