app

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

commit 96e6294d9440d9fe46cc06792b3a424f04dda30b
parent d3fd495e7b3c59ec396a8f89eb027ed9de0f3f3c
Author: triesap <tyson@radroots.org>
Date:   Wed, 14 Oct 2026 08:57:31 +0000

web: Acknowledge the original inbox probe ciphertext

- Persist only a genuine current self probe under the owner lock and SDK slot.
- Verify native completion and fresh physical wire before issuing a local fact.
- Reject forged custody and preserve original artifacts through uncertain outcomes.
- Prove native lifecycle and quota failures with current and historical guards.

Diffstat:
Aweb/src/lib/persistence/inbox-probes.ts | 311+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/persistence/private-storage.ts | 30++++++++++++++++++++++++++++++
Mweb/tests/e2e/harness/inbox-probe.ts | 211++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
Mweb/tests/e2e/inbox-probe.spec.ts | 597+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/provenance/output.test.mjs | 32++++++++++++++++++++++++++++++++
Aweb/tests/unit/inbox-probe-storage.test.ts | 84+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 30++++++++++++++++++++++++++++--
7 files changed, 1291 insertions(+), 4 deletions(-)

diff --git a/web/src/lib/persistence/inbox-probes.ts b/web/src/lib/persistence/inbox-probes.ts @@ -0,0 +1,311 @@ +import { + inboxProbeGiftwrapSnapshot, + inboxProbeGiftwrapSeal, + type InboxProbeGiftwrap +} from '../nostr/giftwrap-builder.ts'; +import { inboxProbeSealIdentity } from '../nostr/seal-builder.ts'; +import { + inboxProbeSnapshot, + inboxProbeRumorWire, + inboxProbeReservationHandle, + type InboxProbeIdentity +} from '../nostr/inbox-access.ts'; +import { + privateSessionOwnership, + withIdlePrivateLocalStorage, + type PrivateSession +} from '../runtime/private-session.ts'; +import { + privateStorageOwner, + commitPrivateRecord, + observePrivateRecord, + type PrivateStorageRepository, + type PrivateStorageFailure +} from './private-storage.ts'; +import { + decodePrivateRecord, + privateRecordWire, + type PrivateAccessProbe +} from './private-records.ts'; +import { + verifyEnvelope, + verifiedEnvelopeSnapshot +} from '../nostr/verified-envelope.ts'; + +declare const acknowledgementBrand: unique symbol; +export type InboxProbeAcknowledgement = Readonly<{ + [acknowledgementBrand]: true; +}>; +export type InboxProbeCommitResult = + | Readonly<{ + status: 'prepared' | 'existing' | 'reconciled'; + acknowledgement: InboxProbeAcknowledgement; + }> + | Readonly<{ + status: PrivateStorageFailure | 'invalid' | 'busy' | 'stopped'; + disposition: 'original_protected'; + }>; +type Saved = Readonly<{ + repository: PrivateStorageRepository; + session: PrivateSession; + identity: InboxProbeIdentity; + record: PrivateAccessProbe; + wire: string; + current(): boolean; + revoke(): void; +}>; +const acknowledgements = new WeakMap<InboxProbeAcknowledgement, Saved>(); +const actions = new WeakMap< + InboxProbeGiftwrap, + Readonly<{ + repository: PrivateStorageRepository; + session: PrivateSession; + pending(): boolean; + }> +>(); +const refuse = ( + status: PrivateStorageFailure | 'invalid' | 'busy' | 'stopped' +): InboxProbeCommitResult => ({ status, disposition: 'original_protected' }); + +// This owner accepts only the original genuine construction chain. Decoding a +// row, copying a snapshot or supplying the same public key grants no authority. +function input( + repository: PrivateStorageRepository, + session: PrivateSession, + wrap: InboxProbeGiftwrap +) { + const artifact = inboxProbeGiftwrapSnapshot(wrap), + seal = inboxProbeGiftwrapSeal(wrap), + identity = seal && inboxProbeSealIdentity(seal), + reservation = identity && inboxProbeSnapshot(identity), + handle = identity && inboxProbeReservationHandle(identity), + ownership = privateSessionOwnership(session); + if ( + !artifact || + !identity || + !reservation || + !handle || + !ownership?.current() || + !inboxProbeRumorWire(identity, session) || + privateStorageOwner(repository) !== ownership.owner || + reservation.owner !== ownership.owner || + artifact.owner !== reservation.owner || + artifact.destination !== reservation.owner || + artifact.command !== reservation.id || + artifact.rumorHash !== reservation.rumorHash || + artifact.createdAt !== reservation.createdAt + ) + return undefined; + const verified = verifyEnvelope(artifact.wire), + event = verified.ok && verifiedEnvelopeSnapshot(verified.value), + reservationWire = privateRecordWire( + handle, + reservation.owner, + reservation.id + ); + if ( + !event || + !reservationWire || + event.kind !== 1059 || + JSON.stringify(event.tags) !== JSON.stringify([['p', reservation.owner]]) + ) + return undefined; + const record: PrivateAccessProbe = { + ...reservation, + revision: 1, + self: { eventId: event.id, wire: artifact.wire }, + receipts: [] + }, + decoded = decodePrivateRecord( + JSON.stringify(record), + reservation.owner, + reservation.id + ); + if (!decoded.ok) return undefined; + const wire = privateRecordWire( + decoded.value, + reservation.owner, + reservation.id + ); + if (!wire) return undefined; + const frozenReservation = JSON.stringify(reservation), + frozenArtifact = JSON.stringify(artifact); + function current() { + return ( + ownership!.current() && + !!inboxProbeRumorWire(identity!, session) && + privateStorageOwner(repository) === reservation!.owner && + JSON.stringify(inboxProbeSnapshot(identity!)) === frozenReservation && + JSON.stringify(inboxProbeGiftwrapSnapshot(wrap)) === frozenArtifact + ); + } + return current() + ? { + identity, + reservation, + reservationWire, + record, + handle: decoded.value, + wire, + current + } + : undefined; +} + +// Native completion and a separate physical-wire observation are necessary. +// This local acknowledgement permits neither EVENT nor readiness or cleanup. +export async function commitInboxProbe( + repository: PrivateStorageRepository, + session: PrivateSession, + wrap: InboxProbeGiftwrap, + review: unknown +): Promise<InboxProbeCommitResult> { + if ( + typeof window === 'undefined' || + review !== 'reviewed_inbox_probe_commit' || + typeof wrap !== 'object' || + wrap === null + ) + return refuse('invalid'); + const prior = actions.get(wrap); + if (prior?.pending()) return refuse('busy'); + if (prior && (prior.repository !== repository || prior.session !== session)) + return refuse('invalid_scope'); + let pending = true; + let captured: ReturnType<typeof input>; + try { + actions.set(wrap, { repository, session, pending: () => pending }); + captured = input(repository, session, wrap); + if (!captured) return refuse('invalid'); + const original = captured; + if (!navigator.locks?.request) return refuse('unavailable'); + return await navigator.locks.request( + 'harvestcircle:owner:' + original.reservation.owner, + { mode: 'exclusive', ifAvailable: true }, + async (lock) => { + if (!lock) return refuse('busy'); + if (!original.current()) return refuse('stopped'); + const idle = await withIdlePrivateLocalStorage( + session, + async (): Promise<InboxProbeCommitResult> => { + if (!original.current()) return refuse('stopped'); + const { owner, id } = original.reservation, + loaded = await observePrivateRecord( + repository, + 'private_sends', + id + ); + if (!original.current()) return refuse('stopped'); + if (!loaded.ok) return refuse(loaded.reason); + let status: 'prepared' | 'existing' | 'reconciled'; + if (loaded.value.wire === original.wire) { + status = 'existing'; + } else { + if (loaded.value.wire !== original.reservationWire) + return refuse('conflict'); + const committed = await commitPrivateRecord( + repository, + original.handle, + loaded.value.handle + ); + if (!original.current()) return refuse('stopped'); + if (!committed.ok && committed.reason !== 'unknown_completion') + return refuse(committed.reason); + status = !committed.ok + ? 'reconciled' + : committed.value.state === 'existing' + ? 'existing' + : 'prepared'; + } + const readback = await observePrivateRecord( + repository, + 'private_sends', + id + ); + if (!original.current()) return refuse('stopped'); + if (!readback.ok) return refuse(readback.reason); + if (readback.value.wire !== original.wire) + return refuse('conflict'); + // The handle and physical wire have both passed complete-owner + // validation. Their equality is checked independently of metadata + // normalization; equivalent raw JSON changes cannot be hidden. + if ( + privateRecordWire(readback.value.handle, owner, id) !== + original.wire + ) + return refuse('conflict'); + const acknowledgement = Object.freeze( + {} + ) as InboxProbeAcknowledgement; + let revoked = false; + acknowledgements.set(acknowledgement, { + repository, + session, + identity: original.identity, + record: original.record, + wire: original.wire, + current: () => !revoked && original.current(), + revoke: () => { + revoked = true; + } + }); + return { status, acknowledgement }; + } + ); + return idle.ok + ? idle.value + : refuse(original.current() ? 'busy' : 'stopped'); + } + ); + } catch { + return refuse( + captured ? (captured.current() ? 'unavailable' : 'stopped') : 'invalid' + ); + } finally { + pending = false; + if (!captured && !prior) actions.delete(wrap); + } +} + +export function inboxProbeAcknowledgementSnapshot( + acknowledgement: InboxProbeAcknowledgement +) { + const saved = acknowledgements.get(acknowledgement); + return saved?.current() + ? { + record: JSON.parse(JSON.stringify(saved.record)) as PrivateAccessProbe, + fact: 'acknowledged_local_probe_ciphertext_only' as const + } + : undefined; +} + +export async function verifyInboxProbeAcknowledgement( + repository: PrivateStorageRepository, + session: PrivateSession, + acknowledgement: InboxProbeAcknowledgement +): Promise<boolean> { + const saved = acknowledgements.get(acknowledgement); + if ( + !saved || + saved.repository !== repository || + saved.session !== session || + !saved.current() + ) + return false; + const readback = await observePrivateRecord( + repository, + 'private_sends', + saved.record.id + ); + const valid = + saved.current() && + readback.ok && + readback.value.wire === saved.wire && + privateRecordWire( + readback.value.handle, + saved.record.owner, + saved.record.id + ) === saved.wire; + if (!valid) saved.revoke(); + return valid; +} diff --git a/web/src/lib/persistence/private-storage.ts b/web/src/lib/persistence/private-storage.ts @@ -559,6 +559,36 @@ export function retainPrivateReceivedRecord( ); } +// Observe only the selected validated row after actual native completion. The +// handle normalizes metadata; wire is the original physical stored string. +// Whole-wire custody owners must compare wire, not the normalized handle alone. +export function observePrivateRecord( + repository: PrivateStorageRepository, + store: Store, + id: unknown +): Promise< + PrivateStorageResult<Readonly<{ handle: PrivateRecordHandle; wire: string }>> +> { + const scope = scopeOf(repository); + if (!scope) return Promise.resolve(failed('invalid_scope')); + if ( + (store !== 'private_sends' && store !== 'received_envelopes') || + typeof id !== 'string' + ) + return Promise.resolve(failed('invalid_record')); + return transaction<Readonly<{ handle: PrivateRecordHandle; wire: string }>>( + scope, + store, + 'readonly', + (rows) => { + const row = rows.find((row) => row.record.id === id); + return row + ? { ok: true, value: { handle: row.handle, wire: row.wire } } + : failed('invalid_record'); + } + ); +} + export function loadPrivateRecord( repository: PrivateStorageRepository, store: Store, diff --git a/web/tests/e2e/harness/inbox-probe.ts b/web/tests/e2e/harness/inbox-probe.ts @@ -42,6 +42,12 @@ import { type InboxProbeGiftwrap } from '../../../src/lib/nostr/giftwrap-builder.ts'; import { + commitInboxProbe, + inboxProbeAcknowledgementSnapshot, + type InboxProbeAcknowledgement +} from '../../../src/lib/persistence/inbox-probes.ts'; +import { decodePrivateRecord } from '../../../src/lib/persistence/private-records.ts'; +import { getEventHash, generateSecretKey, getPublicKey, @@ -56,6 +62,10 @@ export * from '../../../src/lib/nostr/verify-outbound-envelope.ts'; export * from '../../../src/lib/messaging/inbox-access-controller.ts'; export * from '../../../src/lib/messaging/send-identity.ts'; export * from '../../../src/lib/runtime/private-session.ts'; +export * from '../../../src/lib/persistence/inbox-probes.ts'; +export * from '../../../src/lib/persistence/private-storage.ts'; +export * from '../../../src/lib/persistence/private-records.ts'; +export * from '../../../src/lib/persistence/private-sends.ts'; export type Mode = | 'normal' | 'hold_key' @@ -109,6 +119,7 @@ export async function makeProbeFixture() { operation: InboxProbeSealOperation | undefined, seal: InboxProbeRecipientSeal | undefined, wrap: InboxProbeGiftwrap | undefined; + let acknowledgement: InboxProbeAcknowledgement | undefined; async function pause(stage: string) { if (mode !== 'hold_' + stage) return; waiting = stage; @@ -216,6 +227,21 @@ export async function makeProbeFixture() { } ); } + async function inject(rows: { owner: string; id: string; wire: string }[]) { + const tx = browserDatabaseTransaction( + database, + ['private_sends'], + 'readwrite' + ); + const store = tx.objectStore('private_sends'); + for (const row of rows) store.put(row); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('controlled injection abort')) + ); + }); + } return { ...base, repository, @@ -256,6 +282,24 @@ export async function makeProbeFixture() { operation: () => operation, seal: () => seal, wrap: () => wrap, + acknowledgement: () => acknowledgement, + async commitOriginal(review: unknown = 'reviewed_inbox_probe_commit') { + if (!wrap) throw Error('missing genuine original wrap'); + const result = await commitInboxProbe( + repository, + base.session, + wrap, + review + ); + if ('acknowledgement' in result) acknowledgement = result.acknowledgement; + return { + status: result.status, + snapshot: + 'acknowledgement' in result + ? inboxProbeAcknowledgementSnapshot(result.acknowledgement) + : undefined + }; + }, mode(next: Mode) { mode = next; }, @@ -263,7 +307,115 @@ export async function makeProbeFixture() { settle: () => release?.(), counts: () => ({ keys, encrypts, decrypts, signs }), stored, - async fillCapacity() { + inject, + async removeOriginal() { + if (!identity) throw Error('missing genuine original'); + const record = inboxProbeSnapshot(identity); + if (!record) throw Error('stale actual original'); + const tx = browserDatabaseTransaction( + database, + ['private_sends'], + 'readwrite' + ); + tx.objectStore('private_sends').delete([base.owner, record.id]); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('controlled removal abort')) + ); + }); + }, + installCommitCompletion(action: () => void) { + const original = Object.getOwnPropertyDescriptor( + IDBDatabase.prototype, + 'transaction' + )?.value as IDBDatabase['transaction']; + let fired = false; + IDBDatabase.prototype.transaction = function ( + ...args: Parameters<IDBDatabase['transaction']> + ) { + const tx = original.apply(this, args); + if ( + !fired && + args[1] === 'readwrite' && + tx.objectStoreNames.contains('private_sends') + ) { + fired = true; + tx.addEventListener('complete', action); + } + return tx; + }; + return () => { + IDBDatabase.prototype.transaction = original; + }; + }, + async fillProbeByteHeadroom() { + if (!identity || !wrap) throw Error('missing genuine original'); + const record = inboxProbeSnapshot(identity), + artifact = inboxProbeGiftwrapSnapshot(wrap); + if (!record || !artifact) throw Error('stale genuine original'); + const self = { + eventId: (JSON.parse(artifact.wire) as { id: string }).id, + wire: artifact.wire + }; + // Strict structural filler metadata is not actual transport/nonce evidence. + const filler = { + ...record, + id: crypto.randomUUID(), + revision: 1, + self, + receipts: [] as unknown[] + }; + const fact = { + actionId: crypto.randomUUID(), + origin: record.binding.archiveTargets[0], + role: 'access_archive', + attempt: 1, + eventId: self.eventId, + status: 'accepted', + observedAtMilliseconds: 1, + readbackWire: null + }; + const originalRows = await stored(); + const physicalBytes = (rows: typeof originalRows) => + rows.reduce( + (n, row) => n + new TextEncoder().encode(JSON.stringify(row)).length, + 0 + ); + const baseBytes = physicalBytes(originalRows); + const prepared = JSON.stringify({ ...record, revision: 1, self }); + const growth = + physicalBytes([{ owner: base.owner, id: record.id, wire: prepared }]) - + baseBytes; + const rowAt = (n: number) => ({ + owner: base.owner, + id: filler.id, + wire: JSON.stringify({ + ...filler, + receipts: Array.from({ length: n }, () => fact) + }) + }); + const cap = 8 * 1024 * 1024; + const factBytes = physicalBytes([rowAt(1)]) - physicalBytes([rowAt(0)]); + let low = 0, + high = Math.floor(cap / factBytes) + 2; + while (low + 1 < high) { + const mid = Math.floor((low + high) / 2); + if (baseBytes + physicalBytes([rowAt(mid)]) <= cap) low = mid; + else high = mid; + } + const row = rowAt(low); + const strict = decodePrivateRecord(row.wire, row.owner, row.id); + if (!strict.ok) throw Error('filler must decode strictly'); + await inject([row]); + const before = await stored(), + bytes = physicalBytes(before), + headroom = cap - bytes; + if (headroom < 0 || headroom >= growth || before.length >= 100) + throw Error('actual physical growth boundary missing'); + return { bytes, headroom, growth, count: before.length }; + }, + async fillCapacity(count = 100) { const secret = generateSecretKey(), peer = getPublicKey(secret); secret.fill(0); @@ -273,7 +425,7 @@ export async function makeProbeFixture() { 'readwrite' ), store = tx.objectStore('private_sends'); - for (let i = 0; i < 100; i++) { + for (let i = 0; i < count; i++) { const id = crypto.randomUUID(); store.put({ owner: base.owner, @@ -318,6 +470,61 @@ export async function makeProbeFixture() { IDBObjectStore.prototype.put = original; }; }, + installUncertainCommit() { + const put = Object.getOwnPropertyDescriptor( + IDBObjectStore.prototype, + 'put' + )?.value as IDBObjectStore['put']; + const abort = Object.getOwnPropertyDescriptor( + IDBTransaction.prototype, + 'abort' + )?.value as IDBTransaction['abort']; + let selected: IDBTransaction | undefined, + nativeComplete = 0, + nativeAbort = 0, + putSuccess = 0, + abortRefused = 0; + IDBTransaction.prototype.abort = function ( + ...args: Parameters<IDBTransaction['abort']> + ) { + if (this === selected) { + abortRefused++; + throw Error('controlled abort refusal'); + } + return abort.apply(this, args); + }; + IDBObjectStore.prototype.put = function ( + ...args: Parameters<IDBObjectStore['put']> + ) { + const request = put.apply(this, args); + if (!selected && this.name === 'private_sends') { + selected = this.transaction; + selected.addEventListener('complete', () => { + nativeComplete++; + }); + selected.addEventListener('abort', () => { + nativeAbort++; + }); + request.addEventListener('success', () => { + putSuccess++; + }); + throw Error('controlled failure after actual native put admission'); + } + return request; + }; + return { + counts: () => ({ + nativeComplete, + nativeAbort, + putSuccess, + abortRefused + }), + restore: () => { + IDBObjectStore.prototype.put = put; + IDBTransaction.prototype.abort = abort; + } + }; + }, installChangedReadback() { const original = Object.getOwnPropertyDescriptor( IDBDatabase.prototype, diff --git a/web/tests/e2e/inbox-probe.spec.ts b/web/tests/e2e/inbox-probe.spec.ts @@ -644,3 +644,600 @@ for (const stage of ['key', 'encrypt', 'decrypt', 'sign'] as const) { }); } } + +test('S4A genuine persistence acknowledges only the exact native original ciphertext without provider or transport work', async ({ + page +}) => { + await page.evaluate(() => window.p8Fixture.reserve()); + expect(await page.evaluate(() => window.p8Fixture.prepare())).toBe('wrapped'); + const result = await page.evaluate(async () => { + const f = window.p8Fixture, + api = window.p8, + before = f.counts(); + const result = await f.commitOriginal(); + const ack = f.acknowledgement()!; + const snapshot = api.inboxProbeAcknowledgementSnapshot(ack)!; + const observed = await api.observePrivateRecord( + f.repository, + 'private_sends', + snapshot.record.id + ); + const rumor = JSON.parse( + api.inboxProbeRumorWire(f.probeIdentity()!, f.session)! + ) as { content: string }; + const rows = await f.stored(); + const firstWire = JSON.stringify(rows); + (snapshot.record.binding.readTargets as string[]).pop(); + const repeat = await f.commitOriginal(); + return { + status: result.status, + fact: result.snapshot?.fact, + row: result.snapshot?.record, + exact: observed.ok && observed.value.wire === rows[0].wire, + verified: await api.verifyInboxProbeAcknowledgement( + f.repository, + f.session, + ack + ), + repeated: repeat.status, + unchanged: firstWire === JSON.stringify(await f.stored()), + bodyAbsent: + !firstWire.includes(rumor.content) && + !firstWire.includes(rumor.content.slice(-64)), + ordinaryRejected: + api.pairedDeliveryAcknowledgementSnapshot( + ack as unknown as Parameters< + typeof api.pairedDeliveryAcknowledgementSnapshot + >[0] + ) === undefined, + detached: + api.inboxProbeAcknowledgementSnapshot(ack)?.record.binding.readTargets + .length === 1, + before, + after: f.counts() + }; + }); + expect(result.status).toBe('prepared'); + expect(result.fact).toBe('acknowledged_local_probe_ciphertext_only'); + expect(result.row).toMatchObject({ + family: 'private_access_probe', + revision: 1, + receipts: [], + self: { eventId: expect.any(String), wire: expect.any(String) } + }); + expect(result.repeated).toBe('existing'); + expect( + result.exact && + result.verified && + result.unchanged && + result.bodyAbsent && + result.ordinaryRejected && + result.detached + ).toBe(true); + expect(result.before).toEqual(result.after); + expect( + frames.some((frame) => ['EVENT', 'AUTH'].includes(String(frame[0]))) + ).toBe(false); +}); + +test('S4A simultaneous same-wrap calls admit one native original and return busy for the pending duplicate', async ({ + page +}) => { + await page.evaluate(() => window.p8Fixture.reserve()); + await page.evaluate(() => window.p8Fixture.prepare()); + const result = await page.evaluate(async () => { + const f = window.p8Fixture, + api = window.p8, + before = f.counts(); + const results = await Promise.all( + [1, 2].map(() => + api.commitInboxProbe( + f.repository, + f.session, + f.wrap()!, + 'reviewed_inbox_probe_commit' + ) + ) + ); + return { + statuses: results.map((r) => r.status).sort(), + rows: (await f.stored()).length, + before, + after: f.counts() + }; + }); + expect(result.statuses).toEqual(['busy', 'prepared']); + expect(result.rows).toBe(1); + expect(result.before).toEqual(result.after); +}); + +test('S4A forged wraps, wrong consent and genuine alternate namespace/session cannot borrow the original', async ({ + page +}) => { + await page.evaluate(() => window.p8Fixture.reserve()); + await page.evaluate(() => window.p8Fixture.prepare()); + const result = await page.evaluate(async () => { + const f = window.p8Fixture, + api = window.p8; + const other = await f.foreignSession(), + before = f.counts(), + rows = await f.stored(); + const wrap = f.wrap()!, + copy = api.inboxProbeGiftwrapSnapshot(wrap)!; + const results = [ + await api.commitInboxProbe( + f.foreignRepository(), + f.session, + wrap, + 'reviewed_inbox_probe_commit' + ), + await api.commitInboxProbe( + f.repository, + other, + wrap, + 'reviewed_inbox_probe_commit' + ), + await api.commitInboxProbe( + f.repository, + f.session, + copy as unknown as typeof wrap, + 'reviewed_inbox_probe_commit' + ), + await api.commitInboxProbe( + f.repository, + f.session, + wrap, + 'reviewed_private_delivery' + ), + await api.commitInboxProbe( + f.repository, + f.session, + f.seal()! as unknown as typeof wrap, + 'reviewed_inbox_probe_commit' + ) + ]; + const genuine = await f.commitOriginal(); + const primitiveStatuses = []; + for (const primitive of [null, 0, 'wrap', true]) { + primitiveStatuses.push( + ( + await api.commitInboxProbe( + f.repository, + f.session, + primitive as unknown as typeof wrap, + 'reviewed_inbox_probe_commit' + ) + ).status + ); + } + const ack = f.acknowledgement()!; + return { + statuses: results.map((r) => r.status), + primitiveStatuses, + originalWasProtected: rows[0].wire.includes('"self":null'), + genuine: genuine.status, + forgedAck: await api.verifyInboxProbeAcknowledgement( + f.repository, + f.session, + genuine.snapshot as unknown as typeof ack + ), + foreign: await api.verifyInboxProbeAcknowledgement( + f.foreignRepository(), + f.session, + ack + ), + other: await api.verifyInboxProbeAcknowledgement( + f.repository, + other, + ack + ), + actual: await api.verifyInboxProbeAcknowledgement( + f.repository, + f.session, + ack + ), + before, + after: f.counts() + }; + }); + expect(result.statuses).toEqual([ + 'invalid', + 'invalid', + 'invalid', + 'invalid', + 'invalid' + ]); + expect(result.primitiveStatuses).toEqual([ + 'invalid', + 'invalid', + 'invalid', + 'invalid' + ]); + expect(result.originalWasProtected).toBe(true); + expect(result.genuine).toBe('prepared'); + expect(result.forgedAck || result.foreign || result.other).toBe(false); + expect(result.actual).toBe(true); + expect(result.before).toEqual(result.after); +}); + +test('S4A actual owner lock and SDK slot contention preserve the native reservation for an explicit original retry', async ({ + page +}) => { + await page.evaluate(() => window.p8Fixture.reserve()); + await page.evaluate(() => window.p8Fixture.prepare()); + const result = await page.evaluate(async () => { + const f = window.p8Fixture, + api = window.p8, + rows = JSON.stringify(await f.stored()), + before = f.counts(); + let releaseLock = () => {}, + entered = () => {}; + const enteredPromise = new Promise<void>((resolve) => { + entered = resolve; + }); + const held = navigator.locks.request( + 'harvestcircle:owner:' + f.owner, + async () => { + entered(); + await new Promise<void>((resolve) => { + releaseLock = resolve; + }); + } + ); + await enteredPromise; + const lock = await f.commitOriginal(); + releaseLock(); + await held; + let releaseSlot = () => {}, + slotEntered = () => {}; + const slotPromise = new Promise<void>((resolve) => { + slotEntered = resolve; + }); + const slot = api.withIdlePrivateLocalStorage(f.session, async () => { + slotEntered(); + await new Promise<void>((resolve) => { + releaseSlot = resolve; + }); + }); + await slotPromise; + const busy = await f.commitOriginal(); + const unchanged = rows === JSON.stringify(await f.stored()); + releaseSlot(); + await slot; + const original = await f.commitOriginal(); + return { + lock: lock.status, + busy: busy.status, + unchanged, + original: original.status, + before, + after: f.counts() + }; + }); + expect(result).toMatchObject({ + lock: 'busy', + busy: 'busy', + unchanged: true, + original: 'prepared' + }); + expect(result.before).toEqual(result.after); +}); + +test('S4A put success followed by native abort cannot issue a saved fact or alter the original reservation', async ({ + page +}) => { + await page.evaluate(() => window.p8Fixture.reserve()); + await page.evaluate(() => window.p8Fixture.prepare()); + const before = await page.evaluate(() => window.p8Fixture.stored()); + await page.evaluate(() => { + window.p8Restore = window.p8Fixture.installNativeAbort(); + }); + expect(await page.evaluate(() => window.p8Fixture.commitOriginal())).toEqual({ + status: 'aborted', + snapshot: undefined + }); + expect(await page.evaluate(() => window.p8Fixture.stored())).toEqual(before); + expect( + await page.evaluate(() => window.p8Fixture.acknowledgement()) + ).toBeUndefined(); + await page.evaluate(() => { + window.p8Restore?.(); + window.p8Restore = undefined; + }); + expect( + await page.evaluate(() => window.p8Fixture.commitOriginal()) + ).toMatchObject({ status: 'prepared' }); +}); + +test('S4A genuine uncertain native completion reconciles the exact original once without rebuilding crypto', async ({ + page +}) => { + await page.evaluate(() => window.p8Fixture.reserve()); + await page.evaluate(() => window.p8Fixture.prepare()); + const result = await page.evaluate(async () => { + const f = window.p8Fixture, + api = window.p8, + before = f.counts(); + const uncertain = f.installUncertainCommit(); + window.p8Restore = uncertain.restore; + try { + const result = await f.commitOriginal(); + const firstRows = JSON.stringify(await f.stored()); + const ack = f.acknowledgement()!; + const verified = await api.verifyInboxProbeAcknowledgement( + f.repository, + f.session, + ack + ); + uncertain.restore(); + window.p8Restore = undefined; + const repeated = await f.commitOriginal(); + return { + status: result.status, + verified, + counts: uncertain.counts(), + repeated: repeated.status, + exactOriginal: firstRows === JSON.stringify(await f.stored()), + before, + after: f.counts() + }; + } finally { + uncertain.restore(); + window.p8Restore = undefined; + } + }); + expect(result).toMatchObject({ + status: 'reconciled', + verified: true, + repeated: 'existing', + exactOriginal: true, + counts: { + nativeComplete: 1, + nativeAbort: 0, + putSuccess: 1, + abortRefused: 1 + } + }); + expect(result.before).toEqual(result.after); +}); + +for (const close of ['controller', 'session', 'head'] as const) { + test(`S4A ${close} loss at actual native completion protects saved ciphertext but issues no live acknowledgement`, async ({ + page + }) => { + await page.evaluate(() => window.p8Fixture.reserve()); + await page.evaluate(() => window.p8Fixture.prepare()); + await page.evaluate((close) => { + const f = window.p8Fixture; + window.p8Restore = f.installCommitCompletion(() => { + if (close === 'controller') + window.p8.closeInboxAccessController(f.controller()!); + else if (close === 'session') f.closeSession(); + else f.churnHead(); + }); + }, close); + expect( + await page.evaluate(() => window.p8Fixture.commitOriginal()) + ).toEqual({ status: 'stopped', snapshot: undefined }); + const rows = await page.evaluate(() => window.p8Fixture.stored()); + expect(rows).toHaveLength(1); + expect(JSON.parse(rows[0].wire)).toMatchObject({ + revision: 1, + self: { wire: expect.any(String) } + }); + expect( + await page.evaluate(() => window.p8Fixture.acknowledgement()) + ).toBeUndefined(); + expect( + frames.some((frame) => ['EVENT', 'AUTH'].includes(String(frame[0]))) + ).toBe(false); + }); +} + +test('S4A physical whitespace aliases remain detectable despite identical decoded canonical metadata', async ({ + page +}) => { + await page.evaluate(() => window.p8Fixture.reserve()); + await page.evaluate(() => window.p8Fixture.prepare()); + const result = await page.evaluate(async () => { + const f = window.p8Fixture, + api = window.p8; + await f.commitOriginal(); + const ack = f.acknowledgement()!, + row = (await f.stored())[0]; + const before = await api.loadPrivateRecord( + f.repository, + 'private_sends', + row.id + ); + await f.inject([{ ...row, wire: ' ' + row.wire + '\n' }]); + const after = await api.loadPrivateRecord( + f.repository, + 'private_sends', + row.id + ); + const observed = await api.observePrivateRecord( + f.repository, + 'private_sends', + row.id + ); + const canonicalSame = + before.ok && + after.ok && + api.privateRecordWire(before.value, f.owner, row.id) === + api.privateRecordWire(after.value, f.owner, row.id); + const verified = await api.verifyInboxProbeAcknowledgement( + f.repository, + f.session, + ack + ); + const revoked = api.inboxProbeAcknowledgementSnapshot(ack) === undefined; + const retry = await f.commitOriginal(); + return { + canonicalSame, + actualChanged: observed.ok && observed.value.wire !== row.wire, + verified, + revoked, + retry: retry.status, + count: (await f.stored()).length + }; + }); + expect(result).toEqual({ + canonicalSame: true, + actualChanged: true, + verified: false, + revoked: true, + retry: 'conflict', + count: 1 + }); +}); + +test('S4A equivalent physical mutation queued before fresh native readback prevents the first acknowledgement', async ({ + page +}) => { + await page.evaluate(() => window.p8Fixture.reserve()); + await page.evaluate(() => window.p8Fixture.prepare()); + await page.evaluate(() => { + const f = window.p8Fixture, + record = window.p8.inboxProbeSnapshot(f.probeIdentity()!)!, + artifact = window.p8.inboxProbeGiftwrapSnapshot(f.wrap()!)!; + const wire = JSON.stringify({ + ...record, + revision: 1, + self: { + eventId: (JSON.parse(artifact.wire) as { id: string }).id, + wire: artifact.wire + } + }); + window.p8Restore = f.installCommitCompletion(() => { + void f.inject([{ owner: f.owner, id: record.id, wire: ' ' + wire }]); + }); + }); + expect(await page.evaluate(() => window.p8Fixture.commitOriginal())).toEqual({ + status: 'conflict', + snapshot: undefined + }); + expect( + await page.evaluate(() => window.p8Fixture.acknowledgement()) + ).toBeUndefined(); + expect(await page.evaluate(() => window.p8Fixture.stored())).toHaveLength(1); +}); + +for (const mutation of [ + 'metadata', + 'later_facts', + 'corrupt_tail', + 'removed' +] as const) { + test(`S4A fresh acknowledgement verification revokes ${mutation} custody without recreating an artifact`, async ({ + page + }) => { + await page.evaluate(() => window.p8Fixture.reserve()); + await page.evaluate(() => window.p8Fixture.prepare()); + const result = await page.evaluate(async (mutation) => { + const f = window.p8Fixture, + api = window.p8; + await f.commitOriginal(); + const ack = f.acknowledgement()!, + row = (await f.stored())[0]; + const record = JSON.parse(row.wire) as { + createdAt: number; + revision: number; + self: { eventId: string }; + binding: { archiveTargets: string[] }; + receipts: unknown[]; + }; + if (mutation === 'removed') await f.removeOriginal(); + else if (mutation === 'corrupt_tail') + await f.inject([ + { owner: f.owner, id: crypto.randomUUID(), wire: 'broken' } + ]); + else { + if (mutation === 'metadata') record.createdAt++; + else { + record.revision++; + record.receipts.push({ + actionId: crypto.randomUUID(), + origin: record.binding.archiveTargets[0], + role: 'access_archive', + attempt: 1, + eventId: record.self.eventId, + status: 'accepted', + observedAtMilliseconds: 1, + readbackWire: null + }); + } + await f.inject([{ ...row, wire: JSON.stringify(record) }]); + } + const before = f.counts(); + const verified = await api.verifyInboxProbeAcknowledgement( + f.repository, + f.session, + ack + ); + const retry = await f.commitOriginal(); + return { + verified, + revoked: api.inboxProbeAcknowledgementSnapshot(ack) === undefined, + status: retry.status, + before, + after: f.counts() + }; + }, mutation); + expect(result.verified).toBe(false); + expect(result.revoked).toBe(true); + expect(['conflict', 'invalid_record', 'corrupt_record']).toContain( + result.status + ); + expect(result.before).toEqual(result.after); + }); +} + +test('S4A preparation grows the existing row at the full joint 100-row ceiling', async ({ + page +}) => { + await page.evaluate(() => window.p8Fixture.reserve()); + await page.evaluate(() => window.p8Fixture.prepare()); + await page.evaluate(() => window.p8Fixture.fillCapacity(99)); + expect(await page.evaluate(() => window.p8Fixture.stored())).toHaveLength( + 100 + ); + expect( + await page.evaluate(() => window.p8Fixture.commitOriginal()) + ).toMatchObject({ status: 'prepared' }); + expect(await page.evaluate(() => window.p8Fixture.stored())).toHaveLength( + 100 + ); +}); + +test('S4A actual complete row bytes refuse artifact growth with bounded structural filler and preserve the original', async ({ + page +}) => { + await page.evaluate(() => window.p8Fixture.reserve()); + await page.evaluate(() => window.p8Fixture.prepare()); + const bound = await page.evaluate(() => + window.p8Fixture.fillProbeByteHeadroom() + ); + expect(bound.count).toBe(2); + expect(bound.bytes).toBeLessThanOrEqual(8 * 1024 * 1024); + expect(bound.headroom).toBeLessThan(bound.growth); + const result = await page.evaluate(async () => { + const f = window.p8Fixture, + before = JSON.stringify(await f.stored()), + counts = f.counts(); + const result = await f.commitOriginal(); + return { + status: result.status, + unchanged: before === JSON.stringify(await f.stored()), + noAcknowledgement: f.acknowledgement() === undefined, + counts, + after: f.counts() + }; + }); + expect(result).toMatchObject({ + status: 'capacity', + unchanged: true, + noAcknowledgement: true + }); + expect(result.counts).toEqual(result.after); +}); diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -611,6 +611,37 @@ import { auditOutput } from '../../tools/check-output.mjs'; Object.values(manifest).some((row) => row.name === 'view-context') ); assert.ok((await f.audit()).length > 0); + for (const producer of [ + 'src/lib/persistence/private-storage.ts', + 'src/lib/persistence/inbox-probes.ts' + ]) { + for (const change of ['changed', 'missing']) { + await t.test( + 'HCP115 shared probe storage rejects ' + change + ' ' + producer, + async () => { + const file = path.join(f.web, producer), + original = await readFile(file); + try { + if (change === 'changed') + await writeFile( + file, + Buffer.concat([original, Buffer.from('\n')]) + ); + else await rm(file); + await refresh(f); + await assert.rejects( + f.audit, + /Invalid owned probe storage source|ENOENT/ + ); + } finally { + await writeFile(file, original); + await refresh(f); + } + assert.ok((await f.audit()).length > 0); + } + ); + } + } const handles = Object.values(manifest).find( (row) => row.name === 'private-handles' ); @@ -1937,6 +1968,7 @@ import { auditOutput } from '../../tools/check-output.mjs'; ); } for (const producer of [ + 'src/lib/persistence/inbox-probes.ts', 'src/lib/nostr/inbox-access.ts', 'src/lib/nostr/seal-builder.ts', 'src/lib/nostr/giftwrap-builder.ts', diff --git a/web/tests/unit/inbox-probe-storage.test.ts b/web/tests/unit/inbox-probe-storage.test.ts @@ -0,0 +1,84 @@ +import { afterEach, expect, it, vi } from 'vitest'; +import type { PrivateSession } from '../../src/lib/runtime/private-session.ts'; +import type { PrivateStorageRepository } from '../../src/lib/persistence/private-storage.ts'; +import type { InboxProbeGiftwrap } from '../../src/lib/nostr/giftwrap-builder.ts'; +import type { InboxProbeAcknowledgement } from '../../src/lib/persistence/inbox-probes.ts'; +import { pairedDeliveryAcknowledgementSnapshot } from '../../src/lib/persistence/private-sends.ts'; + +afterEach(() => vi.unstubAllGlobals()); +it('cold SSR probe persistence import and forged acknowledgements have no browser effects', async () => { + vi.resetModules(); + const api = await import('../../src/lib/persistence/inbox-probes.ts'); + expect( + await api.commitInboxProbe( + {} as PrivateStorageRepository, + {} as PrivateSession, + {} as InboxProbeGiftwrap, + 'reviewed_inbox_probe_commit' + ) + ).toEqual({ status: 'invalid', disposition: 'original_protected' }); + expect( + api.inboxProbeAcknowledgementSnapshot({} as InboxProbeAcknowledgement) + ).toBeUndefined(); + expect( + await api.verifyInboxProbeAcknowledgement( + {} as PrivateStorageRepository, + {} as PrivateSession, + {} as InboxProbeAcknowledgement + ) + ).toBe(false); +}); + +it('browser-shaped forged inputs and consent coercion cannot access storage or a provider', async () => { + vi.resetModules(); + let observations = 0; + const trap = () => { + observations++; + throw Error('unreviewed browser work'); + }; + vi.stubGlobal('window', { + get nostr() { + return trap(); + } + }); + vi.stubGlobal('navigator', { + get locks() { + return trap(); + } + }); + const api = await import('../../src/lib/persistence/inbox-probes.ts'); + const copy = Object.freeze({ owner: 'a'.repeat(64), current: () => true }); + for (const primitive of [null, undefined, false, 0, 'wrap', Symbol()]) { + expect( + await api.commitInboxProbe( + copy as unknown as PrivateStorageRepository, + copy as unknown as PrivateSession, + primitive as unknown as InboxProbeGiftwrap, + 'reviewed_inbox_probe_commit' + ) + ).toEqual({ status: 'invalid', disposition: 'original_protected' }); + } + for (const review of ['reviewed_inbox_probe_commit', { toString: trap }]) { + expect( + await api.commitInboxProbe( + copy as unknown as PrivateStorageRepository, + copy as unknown as PrivateSession, + copy as unknown as InboxProbeGiftwrap, + review + ) + ).toEqual({ status: 'invalid', disposition: 'original_protected' }); + } + expect( + api.inboxProbeAcknowledgementSnapshot( + copy as unknown as InboxProbeAcknowledgement + ) + ).toBeUndefined(); + expect( + pairedDeliveryAcknowledgementSnapshot( + copy as unknown as Parameters< + typeof pairedDeliveryAcknowledgementSnapshot + >[0] + ) + ).toBeUndefined(); + expect(observations).toBe(0); +}); diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -322,6 +322,8 @@ async function operationalFlagsAdmission(web) { 'b4c718364625b3caacbc5cc5f98bd79a575a5d66dddb2d7f59f03351a1308a6d', 'src/lib/nostr/inbox-ingress.ts': 'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb', + 'src/lib/persistence/inbox-probes.ts': + '7441272a31386a4a70791269c31d55adaa11978ffcb094a98a5a83162aae2f99', 'src/lib/nostr/inbox-access.ts': 'fcd0a3aa216bd092b84e8ea1f4824f047367eaec6ed4e16715612554244eab0b', 'src/lib/nostr/seal-builder.ts': @@ -401,7 +403,7 @@ async function operationalFlagsAdmission(web) { 'src/lib/persistence/private-sends.ts': '6696f4179370cad373c06debf57b919598d53b3d25b6d2a6054a557608e4eb9c', 'src/lib/persistence/private-storage.ts': - '66bab9a0a0a699b70ecba75c002ac0de20a84f3d015f5caefbe1697d0f6456bf', + 'ba4a61dd1fa08fc89d00adac3c258c1f6ae7e5c1b15165facffe76ddd71d5e91', 'src/lib/persistence/public-publications.ts': 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', 'src/lib/persistence/public-receipts.ts': @@ -596,6 +598,8 @@ async function privacyDataAdmission(web) { 'b4c718364625b3caacbc5cc5f98bd79a575a5d66dddb2d7f59f03351a1308a6d', 'src/lib/nostr/inbox-ingress.ts': 'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb', + 'src/lib/persistence/inbox-probes.ts': + '7441272a31386a4a70791269c31d55adaa11978ffcb094a98a5a83162aae2f99', 'src/lib/nostr/inbox-access.ts': 'fcd0a3aa216bd092b84e8ea1f4824f047367eaec6ed4e16715612554244eab0b', 'src/lib/nostr/seal-builder.ts': @@ -669,7 +673,7 @@ async function privacyDataAdmission(web) { 'src/lib/persistence/private-sends.ts': '6696f4179370cad373c06debf57b919598d53b3d25b6d2a6054a557608e4eb9c', 'src/lib/persistence/private-storage.ts': - '66bab9a0a0a699b70ecba75c002ac0de20a84f3d015f5caefbe1697d0f6456bf', + 'ba4a61dd1fa08fc89d00adac3c258c1f6ae7e5c1b15165facffe76ddd71d5e91', 'src/lib/persistence/public-publications.ts': 'be99c4114fb32880e0a9b48ab3593645532853fb4166fb506f398416db41a194', 'src/lib/persistence/public-receipts.ts': @@ -2153,6 +2157,24 @@ async function inboxSetupAdmission(web) { } return true; } +// The historical inbox compiler may consume this exact current shared storage +// owner. Both producer identities are required; no old view pin is refreshed. +/** @param {string} web */ +async function inboxProbeStorageAdmission(web) { + const producers = { + 'src/lib/persistence/private-storage.ts': + 'ba4a61dd1fa08fc89d00adac3c258c1f6ae7e5c1b15165facffe76ddd71d5e91', + 'src/lib/persistence/inbox-probes.ts': + '7441272a31386a4a70791269c31d55adaa11978ffcb094a98a5a83162aae2f99' + }; + for (const [name, pin] of Object.entries(producers)) { + const bytes = await readOwned(web, name); + publicText(bytes); + if (createHash('sha256').update(bytes).digest('hex') !== pin) + throw new Error('Invalid owned probe storage source'); + } + return true; +} /** @param {string} web */ async function inboxPresentationAdmission(web) { const route = await readOwned(web, 'src/routes/messages/+page.svelte'); @@ -2207,6 +2229,10 @@ async function inboxPresentationAdmission(web) { publicText(bytes); if ( createHash('sha256').update(bytes).digest('hex') !== pin && + !( + name === 'src/lib/persistence/private-storage.ts' && + (await inboxProbeStorageAdmission(web)) + ) && !(await privateBlockingAdmission(web)) ) throw new Error('Invalid owned inbox presentation source');