app

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

commit 1bc436861d733b73797ee29a3f8456e0f7315ff5
parent ab68842e98d974d52c8a0169d556efe27d124e02
Author: triesap <tyson@radroots.org>
Date:   Wed, 14 Oct 2026 18:14:36 +0000

web: Recover original persisted inbox access probes

- Validate the stored self artifact under fresh exact owner and route bindings
- Keep recovered nonce proofs opaque and revoke them before lifecycle cleanup
- Reject invalid controller associations before passive private session access
- Cover native custody, actual SDK boundaries and browser reload recovery

Diffstat:
Mweb/src/lib/messaging/inbox-access-controller.ts | 10+++++-----
Mweb/src/lib/nostr/inbox-access.ts | 62++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/nostr/self-recovery-reader.ts | 461++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
Aweb/tests/e2e/harness/inbox-probe-recovery.ts | 762+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/inbox-probe-recovery.spec.ts | 1306+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/provenance/output.test.mjs | 4++--
Aweb/tests/unit/inbox-probe-recovery.test.ts | 174+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 12++++++------
8 files changed, 2775 insertions(+), 16 deletions(-)

diff --git a/web/src/lib/messaging/inbox-access-controller.ts b/web/src/lib/messaging/inbox-access-controller.ts @@ -359,16 +359,16 @@ export function inboxAccessConstructionBinding( session: PrivateSession, policy: RelayPolicy ): Readonly<Binding & { session: symbol; current(): boolean }> | undefined { - const state = controllers.get(token), - ownership = privateSessionOwnership(session); + const state = controllers.get(token); if ( !state || + state.closed() || state.session !== session || - state.policy !== policy || - !ownership?.current() || - !state.current() + state.policy !== policy ) return undefined; + const ownership = privateSessionOwnership(session); + if (!ownership?.current() || !state.current()) return undefined; const captured = state.snapshot(); if ( captured.owner !== ownership.owner || diff --git a/web/src/lib/nostr/inbox-access.ts b/web/src/lib/nostr/inbox-access.ts @@ -1,3 +1,6 @@ +import { canonicalPublicKey } from '../contracts/public-key.ts'; +import { exactLocalFields } from '../contracts/local-records.ts'; +import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts'; import { getEventHash, type UnsignedEvent } from 'applesauce-core/helpers'; import { readRelayPolicy, type RelayPolicy } from '../config/relays.ts'; import { @@ -214,6 +217,10 @@ export async function reserveInboxProbeIdentity( } if (!wire || !actorCurrent()) return refuse('stopped'); const rumorHash = (JSON.parse(wire) as { id: string }).id; + if ( + !inboxProbeRumorMatches(wire, owner.owner, rumorHash, createdAt) + ) + return refuse('invalid_record'); const record: PrivateAccessProbe = { schema: 1, family: 'private_access_probe', @@ -372,3 +379,58 @@ export function inboxProbePolicyMatches( saved.current() ); } + +// Detached inspection only. Actual SDK decryption and original native/current +// associations are necessary to issue a recovered probe capability. +export function inboxProbeRumorMatches( + raw: unknown, + owner: unknown, + hash: unknown, + createdAt: unknown +): boolean { + const author = canonicalPublicKey(owner); + if ( + !author || + typeof hash !== 'string' || + !/^[0-9a-f]{64}$/.test(hash) || + safeUnsignedInteger(createdAt) === undefined || + typeof raw !== 'string' || + !boundedUtf8(raw, 8192) + ) + return false; + try { + const rumor: unknown = JSON.parse(raw); + if ( + !exactLocalFields(rumor, [ + 'id', + 'pubkey', + 'created_at', + 'kind', + 'tags', + 'content' + ]) || + rumor.id !== hash || + rumor.pubkey !== author || + rumor.created_at !== createdAt || + rumor.kind !== 14 || + JSON.stringify(rumor.tags) !== JSON.stringify([['p', author]]) || + typeof rumor.content !== 'string' || + !rumor.content.startsWith(diagnostic) || + !/^[0-9a-f]{64}$/.test(rumor.content.slice(diagnostic.length)) + ) + return false; + const event: UnsignedEvent = { + pubkey: author, + created_at: createdAt as number, + kind: 14, + tags: [['p', author]], + content: rumor.content + }; + return ( + getEventHash(event) === hash && + JSON.stringify({ id: hash, ...event }) === raw + ); + } catch { + return false; + } +} diff --git a/web/src/lib/nostr/self-recovery-reader.ts b/web/src/lib/nostr/self-recovery-reader.ts @@ -12,7 +12,18 @@ import { inboxProbePublicationBinding, type InboxProbeAcknowledgement } from '../persistence/inbox-probes.ts'; -import { inboxProbeRumorWire } from './inbox-access.ts'; +import { inboxProbeRumorWire, inboxProbeRumorMatches } from './inbox-access.ts'; +import { + inboxAccessConstructionBinding, + subscribeInboxAccessControllerClose, + type InboxAccessController +} from '../messaging/inbox-access-controller.ts'; +import { + inboxOperatorQualificationWire, + inboxOperatorQualificationSnapshot, + type InboxOperatorQualification +} from '../config/inbox-operators.ts'; +import { readRelayPolicy } from '../config/relays.ts'; import { inboxProbeReadbackMatches } from '../persistence/private-records.ts'; import { ExtensionSigner } from 'applesauce-signers'; import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts'; @@ -28,13 +39,16 @@ import { import { loadPrivateRecord, observePrivateRecord, + privateStorageOwner, type PrivateStorageRepository, type PrivateStorageFailure } from '../persistence/private-storage.ts'; import { privateRecordSnapshot, privateRecordWire, - type PrivateSendOperation + type PrivateSendOperation, + type PrivateAccessProbe, + type PrivateRecordHandle } from '../persistence/private-records.ts'; import { verifyEnvelope, @@ -50,7 +64,7 @@ import { markExtensionWaitExpired, type ExtensionAction } from './extension-scheduler.ts'; -// Module-private strict self-layer SDK engine. Only the two factory-owned reader +// Module-private strict self-layer SDK engine. Only the factory-owned reader // scopes below provide ownership/currentness; no caller cipher/event port exists. function strictSelfDecryptor( identity: IdentitySession, @@ -786,3 +800,444 @@ export function inboxProbeNonceProofBinding( current: () => saved.current() }; } + +declare const probeRecoveryReaderBrand: unique symbol; +export type InboxProbeRecoveryReader = Readonly<{ + [probeRecoveryReaderBrand]: true; +}>; +declare const recoveredProbeBrand: unique symbol; +export type RecoveredInboxProbe = Readonly<{ [recoveredProbeBrand]: true }>; +export type InboxProbeRecoveryResult = + | Readonly<{ status: 'recovered'; proof: RecoveredInboxProbe }> + | Readonly<{ + status: + | PrivateStorageFailure + | 'invalid' + | 'stopped' + | 'busy' + | 'refused' + | 'mismatch' + | 'lost_evidence'; + }>; +type ProbeRecoveryReader = { + run(): Promise<InboxProbeRecoveryResult>; + stop(expired: boolean): void; +}; +const recoveryCaptures = new WeakMap<InboxAccessController, true>(); +const recoveryReaders = new WeakMap< + InboxProbeRecoveryReader, + ProbeRecoveryReader +>(); +const accessRecoveryReaders = new WeakMap< + InboxAccessController, + Readonly<{ + repository: PrivateStorageRepository; + identity: IdentitySession; + session: PrivateSession; + policy: RelayPolicy; + operator: InboxOperatorQualification; + id: string; + reader: InboxProbeRecoveryReader; + }> +>(); +const recoveredProbes = new WeakMap< + RecoveredInboxProbe, + Readonly<{ + repository: PrivateStorageRepository; + identity: IdentitySession; + session: PrivateSession; + access: InboxAccessController; + policy: RelayPolicy; + operator: InboxOperatorQualification; + record: PrivateAccessProbe; + handle: PrivateRecordHandle; + storedWire: string; + rumor(): string | undefined; + current(): boolean; + }> +>(); + +// Capture supplies no key, native read or socket. Explicit run decrypts only the +// stored original under genuine owner/controller/configuration authorization. +export function captureInboxProbeRecoveryReader( + repository: PrivateStorageRepository, + identity: IdentitySession, + session: PrivateSession, + policy: RelayPolicy, + access: InboxAccessController, + operator: InboxOperatorQualification, + localId: unknown, + review: unknown +): InboxProbeRecoveryReader | undefined { + if ( + typeof window === 'undefined' || + review !== 'reviewed_inbox_probe_recovery' + ) + return undefined; + if ( + (typeof access !== 'object' && typeof access !== 'function') || + access === null || + recoveryCaptures.has(access) + ) + return undefined; + recoveryCaptures.set(access, true); + try { + const id = canonicalLocalId(localId), + configuredWire = inboxOperatorQualificationWire(operator, policy), + manifest = inboxOperatorQualificationSnapshot(operator), + owner = privateStorageOwner(repository); + if ( + !id || + !owner || + !configuredWire || + !manifest || + manifest.authority === 'unconfigured' + ) + return undefined; + const identityOwner = identityMessagingOwnership(identity); + if (!identityOwner?.current() || identityOwner.owner !== owner) + return undefined; + // The controller's genuine session/policy association is checked before + // passive session ownership, including its retained failed-cleanup retry. + const metadata = inboxAccessConstructionBinding(access, session, policy); + if ( + !metadata || + metadata.owner !== owner || + !metadata.current() || + ![...metadata.readTargets, ...metadata.archiveTargets].every((origin) => { + const row = manifest.relays.find((x) => x.origin === origin); + return ( + row && + row.auth !== 'unsupported' && + row.recipientRead === 'supported' && + row.namedArchiveAck === 'supported' && + row.exactReadback === 'supported' && + row.retention === 'operator_defined' + ); + }) + ) + return undefined; + if (!identityOwner.current() || identityOwner.session !== metadata.session) + return undefined; + const privateOwner = privateSessionOwnership(session); + if ( + !privateOwner?.current() || + privateOwner.owner !== owner || + privateOwner.session !== identityOwner.session + ) + return undefined; + const previous = accessRecoveryReaders.get(access); + if (previous) + return previous.repository === repository && + previous.identity === identity && + previous.session === session && + previous.policy === policy && + previous.operator === operator && + previous.id === id + ? previous.reader + : undefined; + const expectedBinding = JSON.stringify({ + preferenceId: metadata.preferenceId, + preferenceCreatedAt: metadata.preferenceCreatedAt, + readTargets: metadata.readTargets, + archiveTargets: metadata.archiveTargets, + policyWire: JSON.stringify(readRelayPolicy(policy)), + operatorWire: configuredWire + }); + const token = Object.freeze({}) as InboxProbeRecoveryReader; + const operation = Symbol(); + let stopped = false, + consumed = false, + pending = false, + selectedWire: string | undefined, + active: ExtensionAction | undefined, + recovered: RecoveredInboxProbe | undefined, + rumorWire: string | undefined, + last: InboxProbeRecoveryResult | undefined; + const listeners = new Map<symbol, () => void>(); + function current() { + if (stopped) return false; + const fresh = + identityOwner!.current() && + privateOwner!.current() && + inboxAccessConstructionBinding(access, session, policy); + const valid = + !!fresh && + fresh.current() && + fresh.owner === owner && + fresh.session === identityOwner!.session && + inboxOperatorQualificationWire(operator, policy) === configuredWire && + JSON.stringify({ + preferenceId: fresh.preferenceId, + preferenceCreatedAt: fresh.preferenceCreatedAt, + readTargets: fresh.readTargets, + archiveTargets: fresh.archiveTargets, + policyWire: JSON.stringify(readRelayPolicy(policy)), + operatorWire: configuredWire + }) === expectedBinding; + if (!valid) stop(false); + return valid && !stopped; + } + function stop(expired: boolean) { + stopped = true; + rumorWire = undefined; + if (recovered) recoveredProbes.delete(recovered); + recovered = undefined; + if (active) { + if (expired) markExtensionWaitExpired(active); + else stopExtensionAction(active); + } + for (const [id, off] of listeners) { + off(); + listeners.delete(id); + } + } + function retain(register: () => () => void) { + const off = register(); + if (stopped) off(); + else listeners.set(Symbol(), off); + } + const decryptor = strictSelfDecryptor(identity, owner, current); + async function run(): Promise<InboxProbeRecoveryResult> { + if (!current()) { + stop(false); + return { status: 'stopped' }; + } + if (pending) return { status: 'busy' }; + if (consumed) return last ?? { status: 'stopped' }; + pending = true; + try { + if (!navigator.locks?.request) + return (last = { status: 'unavailable' }); + last = await navigator.locks.request( + 'harvestcircle:owner:' + owner, + { mode: 'exclusive', ifAvailable: true }, + async (lock): Promise<InboxProbeRecoveryResult> => { + if (!lock) return { status: 'busy' }; + if (!current()) return { status: 'stopped' }; + const loaded = await observePrivateRecord( + repository, + 'private_sends', + id + ); + if (!current()) return { status: 'stopped' }; + if (!loaded.ok) + return { + status: + loaded.reason === 'invalid_record' + ? 'lost_evidence' + : loaded.reason + }; + const record = privateRecordSnapshot( + loaded.value.handle, + owner, + id + ), + storedWire = loaded.value.wire; + if (selectedWire !== undefined && selectedWire !== storedWire) + return { status: 'conflict' }; + if (!record || record.family !== 'private_access_probe') + return { status: 'invalid_scope' }; + if (!record.self || record.revision === 0) + return { status: 'lost_evidence' }; + if ( + privateRecordWire(loaded.value.handle, owner, id) !== + storedWire || + JSON.stringify(record.binding) !== expectedBinding + ) + return { status: 'conflict' }; + const checked = verifyEnvelope(record.self.wire), + outer = checked.ok && verifiedEnvelopeSnapshot(checked.value); + if ( + !outer || + outer.kind !== 1059 || + outer.id !== record.self.eventId || + JSON.stringify(outer.tags) !== JSON.stringify([['p', owner]]) || + !exactLocalFields(outer, [ + 'id', + 'pubkey', + 'created_at', + 'kind', + 'tags', + 'content', + 'sig' + ]) || + !sealCiphertextV2(outer.content) + ) + return { status: 'mismatch' }; + selectedWire ??= storedWire; + const scheduler = browserExtensionScheduler(); + if (!scheduler) return { status: 'unavailable' }; + const result = await runExtensionAction<InboxProbeRecoveryResult>( + scheduler, + { + owner: identityOwner!.owner, + session: identityOwner!.session, + operation + }, + current, + async (action): Promise<InboxProbeRecoveryResult> => { + consumed = true; + active = action; + const opened = await decryptor.open(action, outer); + if (!current()) return { status: 'stopped' }; + if (opened.status !== 'opened') return opened; + if ( + !inboxProbeRumorMatches( + opened.rumorWire, + owner, + record.rumorHash, + record.createdAt + ) + ) + return { status: 'mismatch' }; + // No callback-capable provider work follows this last fresh-key + // step. Final complete native physical read precedes proof mint. + if (!(await decryptor.fresh(action))) + return { status: 'stopped' }; + const after = await observePrivateRecord( + repository, + 'private_sends', + id + ); + if (!current()) return { status: 'stopped' }; + if (!after.ok) return { status: after.reason }; + if ( + after.value.wire !== storedWire || + privateRecordWire(after.value.handle, owner, id) !== + storedWire + ) + return { status: 'conflict' }; + rumorWire = opened.rumorWire; + const proof = Object.freeze({}) as RecoveredInboxProbe; + recoveredProbes.set(proof, { + repository, + identity, + session, + access, + policy, + operator, + record, + handle: after.value.handle, + storedWire, + rumor: () => (current() ? rumorWire : undefined), + current + }); + recovered = proof; + return { status: 'recovered', proof }; + } + ); + if (!current()) { + stop(false); + 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' }; + } + ); + return last; + } catch { + return (last = { status: current() ? 'refused' : 'stopped' }); + } finally { + active = undefined; + pending = false; + } + } + recoveryReaders.set(token, { run, stop }); + accessRecoveryReaders.set(access, { + repository, + identity, + session, + policy, + operator, + id, + reader: token + }); + retain(() => + subscribeIdentityInvalidation(identity, () => { + if (!identityOwner.current()) stop(false); + }) + ); + retain(() => subscribePrivateSessionClose(session, () => stop(false))); + retain(() => + subscribeInboxAccessControllerClose(access, () => stop(false)) + ); + return current() ? token : undefined; + } catch { + return undefined; + } finally { + recoveryCaptures.delete(access); + } +} +export function recoverInboxProbe( + reader: InboxProbeRecoveryReader +): Promise<InboxProbeRecoveryResult> { + return ( + recoveryReaders.get(reader)?.run() ?? Promise.resolve({ status: 'invalid' }) + ); +} +export function stopInboxProbeRecoveryReader(reader: InboxProbeRecoveryReader) { + recoveryReaders.get(reader)?.stop(false); +} +export function expireInboxProbeRecoveryReaderWait( + reader: InboxProbeRecoveryReader +) { + recoveryReaders.get(reader)?.stop(true); +} +// Metadata and strong original associations only, not live native/network +// authority. Later effect owners must independently reread exact physical wire. +export function recoveredInboxProbeBinding( + proof: RecoveredInboxProbe, + repository: PrivateStorageRepository, + session: PrivateSession, + access: InboxAccessController, + policy: RelayPolicy, + operator: InboxOperatorQualification +) { + const saved = recoveredProbes.get(proof); + if ( + !saved || + saved.repository !== repository || + saved.session !== session || + saved.access !== access || + saved.policy !== policy || + saved.operator !== operator || + !saved.current() || + !saved.rumor() + ) + return undefined; + return { + owner: saved.record.owner, + command: saved.record.id, + rumorHash: saved.record.rumorHash, + eventId: saved.record.self!.eventId, + handle: saved.handle, + storedWire: saved.storedWire, + current: () => saved.current() && !!saved.rumor() + }; +} +// Only genuine recovered proof and exact current original scope can expose the +// private original rumor to a later separate source-owned probe admission. +export function recoveredInboxProbeRumorWire( + proof: RecoveredInboxProbe, + repository: PrivateStorageRepository, + session: PrivateSession, + access: InboxAccessController, + policy: RelayPolicy, + operator: InboxOperatorQualification +): string | undefined { + return recoveredInboxProbeBinding( + proof, + repository, + session, + access, + policy, + operator + ) + ? recoveredProbes.get(proof)?.rumor() + : undefined; +} diff --git a/web/tests/e2e/harness/inbox-probe-recovery.ts b/web/tests/e2e/harness/inbox-probe-recovery.ts @@ -0,0 +1,762 @@ +import { makeFixture as makeCryptoFixture } from './approved-signing.ts'; +import { + createIdentitySession, + connectIdentity, + probeIdentityMessaging, + disconnectIdentity +} from '../../../src/lib/runtime/identity-session.ts'; +import { + createPrivateSession, + closePrivateSession +} from '../../../src/lib/runtime/private-session.ts'; +import { + createPublicRuntimeContext, + mountPublicRuntime, + closePublicRuntime, + createPublicView, + beginPublicViewRun, + disposePublicView +} from '../../../src/lib/runtime/public-runtime.ts'; +import { + resolveInboxPreference, + settleInboxResolver +} from '../../../src/lib/messaging/resolve-inbox.ts'; +import { + createInboxAccessController, + closeInboxAccessController +} from '../../../src/lib/messaging/inbox-access-controller.ts'; +import { + openBrowserDatabase, + closeBrowserDatabase, + browserDatabaseTransaction +} from '../../../src/lib/persistence/database.ts'; +import { createPrivateStorageRepository } from '../../../src/lib/persistence/private-storage.ts'; +import { + captureInboxProbeRecoveryReader, + recoverInboxProbe, + recoveredInboxProbeBinding, + stopInboxProbeRecoveryReader, + type InboxProbeRecoveryReader, + type RecoveredInboxProbe +} from '../../../src/lib/nostr/self-recovery-reader.ts'; +import { + reserveInboxProbeIdentity, + inboxProbeSnapshot +} from '../../../src/lib/nostr/inbox-access.ts'; +import { + captureInboxProbeSealOperation, + buildInboxProbeSeal +} from '../../../src/lib/nostr/seal-builder.ts'; +import { buildInboxProbeGiftwrap } from '../../../src/lib/nostr/giftwrap-builder.ts'; +import { + commitInboxProbe, + inboxProbeAcknowledgementSnapshot, + commitInboxProbeArchiveAttempt, + commitInboxProbeReadbackAttempt, + type InboxProbeAcknowledgement +} from '../../../src/lib/persistence/inbox-probes.ts'; +import { + getPrivatePool, + closePrivatePool, + publishInboxProbeArchiveAttempt, + readInboxProbeAttempt, + type PrivatePool, + type InboxProbeArchiveAttemptResult, + type InboxProbeReadbackAttemptResult +} from '../../../src/lib/nostr/private-pool.ts'; +import { + captureInboxProbePublicationAction, + captureInboxProbePublication, + captureInboxProbeReadback, + type InboxProbePublicationAction +} from '../../../src/lib/nostr/private-publisher.ts'; +import { + captureInboxProbeNonceReader, + readInboxProbeNonce, + stopInboxProbeNonceReader, + type InboxProbeNonceReader +} from '../../../src/lib/nostr/self-recovery-reader.ts'; +import type { InboxProbeIdentity } from '../../../src/lib/nostr/inbox-access.ts'; +import type { InboxProbeGiftwrap } from '../../../src/lib/nostr/giftwrap-builder.ts'; +import { + readRelayPolicy, + validateRelayPolicy, + type RelayPolicy +} from '../../../src/lib/config/relays.ts'; +import { + inboxOperatorQualificationWire, + validateInboxOperatorQualification, + type InboxOperatorQualification +} from '../../../src/lib/config/inbox-operators.ts'; +import type { UnsignedEvent } from 'applesauce-core/helpers'; +export * from './inbox-probe-nonce.ts'; +export { + readRelayPolicy, + validateRelayPolicy, + inboxOperatorQualificationWire, + validateInboxOperatorQualification +}; + +// All actors are actual source factories. The emulated extension may outlive a +// product realm, as a real extension does; no secret leaves its test closure. +function createRecoveryPublicScope(policy: RelayPolicy) { + const context = createPublicRuntimeContext(), + runtime = mountPublicRuntime(context, policy); + if (!runtime) throw Error('actual public discovery scope'); + return { context, runtime }; +} +export async function openRecoveryContext( + owner: string, + policy: RelayPolicy, + operator: InboxOperatorQualification, + localId: string, + shared?: ReturnType<typeof createRecoveryPublicScope> +) { + const identity = createIdentitySession(); + await connectIdentity(identity); + await probeIdentityMessaging(identity, 'reviewed_self_copy'); + const session = await createPrivateSession( + identity, + 'reviewed_private_session' + ); + const opened = await openBrowserDatabase(); + if (!session || opened.state !== 'ready') + throw Error('fresh actual recovery actors'); + const repository = createPrivateStorageRepository(opened.owner, owner); + if (!repository) throw Error('actual original native namespace'); + const { context, runtime } = shared ?? createRecoveryPublicScope(policy); + const view = createPublicView(runtime), + run = beginPublicViewRun(view), + resolver = resolveInboxPreference(view, run, owner); + await settleInboxResolver(resolver); + const access = createInboxAccessController(session, policy, resolver); + if (!access) throw Error('fresh actual recovery controller'); + let selected: InboxProbeRecoveryReader | undefined, + proof: RecoveredInboxProbe | undefined; + function capture( + review: unknown = 'reviewed_inbox_probe_recovery', + id: unknown = localId + ) { + return captureInboxProbeRecoveryReader( + repository!, + identity, + session!, + policy, + access!, + operator, + id, + review + ); + } + return { + owner, + identity, + session, + repository, + policy, + operator, + access, + localId, + capture, + reader: () => selected, + proof: () => proof, + binding: () => + proof && + recoveredInboxProbeBinding( + proof, + repository, + session, + access, + policy, + operator + ), + async recover(reader = (selected ??= capture())) { + if (!reader) return { status: 'invalid' as const }; + selected ??= reader; + const result = await recoverInboxProbe(reader); + if ('proof' in result) proof = result.proof; + return result; + }, + churnHead: () => beginPublicViewRun(view), + close() { + if (selected) stopInboxProbeRecoveryReader(selected); + closeInboxAccessController(access); + closePrivateSession(session); + disconnectIdentity(identity); + disposePublicView(view); + if (!shared) closePublicRuntime(context); + closeBrowserDatabase(opened.owner); + } + }; +} +export async function makeRecoveryFixture() { + const host = createHostedProvider(); + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') throw Error('actual original native database'); + const database = opened.owner, + repository = createPrivateStorageRepository(database, host.owner); + if (!repository) throw Error('actual original native namespace'); + const policy = validateRelayPolicy( + JSON.stringify({ + schemaVersion: 1, + public: [ + { + origin: 'wss://discovery.example.org', + read: true, + write: true, + nip50: false + } + ], + inbox: [ + 'wss://inbox.example.org', + 'wss://peer.example.org', + 'wss://archive.example.org' + ].map((origin) => ({ origin, read: true, write: true })), + postingEnabled: true, + messagingEnabled: true, + operatorDenylist: [] + }) + ); + if (!policy) throw Error('actual fixture policy'); + function operator(unsupported = false, unconfigured = false) { + const result = validateInboxOperatorQualification( + JSON.stringify({ + schemaVersion: 1, + revision: 1, + authority: unconfigured ? 'unconfigured' : 'source_fixture', + policyWire: JSON.stringify(readRelayPolicy(policy!)), + evidenceSha256: unconfigured ? null : 'a'.repeat(64), + relays: unconfigured + ? [] + : readRelayPolicy(policy!).inbox.map(({ origin }) => ({ + origin, + auth: 'not_required', + recipientRead: 'supported', + namedArchiveAck: 'supported', + exactReadback: unsupported ? 'unsupported' : 'supported', + retention: 'operator_defined' + })) + }) + ); + if (!result) throw Error('source-labelled supported operator fixture'); + return result; + } + const qualification = operator(); + let publicOwner: ReturnType<typeof createRecoveryPublicScope> | undefined, + original: Awaited<ReturnType<typeof openRecoveryContext>> | undefined, + recovery: Awaited<ReturnType<typeof openRecoveryContext>> | undefined; + let originalId: string | undefined; + let probe: InboxProbeIdentity | undefined, + wrap: InboxProbeGiftwrap | undefined, + acknowledgement: InboxProbeAcknowledgement | undefined, + action: InboxProbePublicationAction | undefined, + pool: PrivatePool | undefined, + lastRead: InboxProbeReadbackAttemptResult | undefined, + nonceReader: InboxProbeNonceReader | undefined; + function context() { + if (!original) throw Error('actual original context missing'); + return original; + } + function acquire() { + const r = context(); + pool ??= getPrivatePool( + r.session, + policy!, + ['wss://inbox.example.org'], + Object.freeze({}), + 'access' + ); + if (!pool) throw Error('actual original probe pool'); + return pool; + } + return { + ...host, + repository, + policy, + qualification, + operator, + get identity() { + return context().identity; + }, + get session() { + return context().session; + }, + controller: () => original?.access, + probeIdentity: () => probe, + async capture() { + publicOwner ??= createRecoveryPublicScope(policy); + original ??= await openRecoveryContext( + host.owner, + policy, + qualification, + crypto.randomUUID(), + publicOwner + ); + return original.access; + }, + async reserve() { + const r = context(), + result = await reserveInboxProbeIdentity( + repository, + r.session, + policy, + r.access, + qualification, + 'reviewed_inbox_probe_reservation' + ); + if ('identity' in result) { + probe = result.identity; + originalId = inboxProbeSnapshot(probe)?.id; + if (!originalId) + throw Error('genuine reserved command metadata missing'); + } + return result; + }, + async prepare() { + const r = context(); + if (!probe) throw Error('actual R0 missing'); + const operation = captureInboxProbeSealOperation( + r.session, + probe, + 'reviewed_inbox_probe_seal' + ); + if (!operation) throw Error('actual seal admission'); + const result = await buildInboxProbeSeal(operation); + if (!('seal' in result)) return result.status; + wrap = buildInboxProbeGiftwrap(result.seal, 'reviewed_inbox_probe_wrap'); + return wrap ? 'wrapped' : 'invalid'; + }, + async commitOriginal() { + if (!wrap) throw Error('actual original wrap missing'); + const result = await commitInboxProbe( + repository, + context().session, + wrap, + 'reviewed_inbox_probe_commit' + ); + if ('acknowledgement' in result) acknowledgement = result.acknowledgement; + return result; + }, + snapshot: () => + acknowledgement && inboxProbeAcknowledgementSnapshot(acknowledgement), + async publish() { + const r = context(); + if (!acknowledgement) throw Error('actual original ACK missing'); + action ??= captureInboxProbePublicationAction( + repository, + r.session, + policy, + acknowledgement, + 'reviewed_inbox_probe_network' + ); + const permission = + action && + captureInboxProbePublication( + repository, + r.session, + policy, + acknowledgement, + action, + 'wss://inbox.example.org', + 'reviewed_inbox_probe_publication' + ); + if (!permission) throw Error('actual original PUB admission'); + return publishInboxProbeArchiveAttempt( + acquire(), + permission, + new AbortController().signal + ); + }, + append: (result: InboxProbeArchiveAttemptResult) => + commitInboxProbeArchiveAttempt(repository, result), + async read() { + const r = context(); + if (!acknowledgement || !action) + throw Error('actual original PUB action missing'); + const permission = captureInboxProbeReadback( + repository, + r.session, + policy, + acknowledgement, + action, + 'wss://inbox.example.org', + 'reviewed_inbox_probe_readback' + ); + if (!permission) throw Error('actual original read admission'); + return (lastRead = await readInboxProbeAttempt( + acquire(), + permission, + new AbortController().signal + )); + }, + appendRead: (result: InboxProbeReadbackAttemptResult) => + commitInboxProbeReadbackAttempt(repository, result), + nonceCapture() { + const r = context(); + return ( + lastRead && + captureInboxProbeNonceReader( + repository, + r.identity, + r.session, + policy, + lastRead, + 'reviewed_inbox_probe_nonce_decryption' + ) + ); + }, + async nonce() { + const r = context(); + nonceReader ??= + lastRead && + captureInboxProbeNonceReader( + repository, + r.identity, + r.session, + policy, + lastRead, + 'reviewed_inbox_probe_nonce_decryption' + ); + return nonceReader + ? readInboxProbeNonce(nonceReader) + : { status: 'invalid' as const }; + }, + nonceReader: () => nonceReader, + foreignRepository() { + const fixture = makeCryptoFixture(); + const other = createPrivateStorageRepository(database, fixture.owner); + fixture.close(); + if (!other) throw Error('actual other namespace'); + return other; + }, + copiedPolicy() { + const other = validateRelayPolicy( + JSON.stringify(readRelayPolicy(policy)) + ); + if (!other) throw Error('actual copied policy'); + return other; + }, + async stored() { + const tx = browserDatabaseTransaction( + database, + ['private_sends'], + 'readonly' + ), + request = tx.objectStore('private_sends').getAll(); + return new Promise<{ owner: string; id: string; wire: string }[]>( + (resolve, reject) => { + tx.addEventListener('complete', () => + resolve( + request.result as { owner: string; id: string; wire: string }[] + ) + ); + tx.addEventListener('abort', () => + reject(Error('actual fixture read abort')) + ); + } + ); + }, + async inject(rows: { owner: string; id: string; wire: string }[]) { + const tx = browserDatabaseTransaction( + database, + ['private_sends'], + 'readwrite' + ); + for (const row of rows) tx.objectStore('private_sends').put(row); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('actual fixture write abort')) + ); + }); + }, + async removeOriginal() { + if (!originalId) throw Error('original command metadata missing'); + const tx = browserDatabaseTransaction( + database, + ['private_sends'], + 'readwrite' + ); + tx.objectStore('private_sends').delete([host.owner, originalId]); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('actual native deletion abort')) + ); + }); + }, + async fresh() { + // Recovery explicitly permits expired original memory authority. Only the + // original genuine reserved ID survives as inert selection metadata. + if (!originalId) throw Error('original command metadata missing'); + const tx = browserDatabaseTransaction( + database, + ['private_sends'], + 'readonly' + ); + const request = tx + .objectStore('private_sends') + .get([host.owner, originalId]); + const row = await new Promise<unknown>((resolve, reject) => { + tx.addEventListener('complete', () => resolve(request.result)); + tx.addEventListener('abort', () => + reject(Error('actual original selection abort')) + ); + }); + if (!row) throw Error('stored original selection missing'); + if (pool) closePrivatePool(pool); + original!.close(); + if (inboxProbeSnapshot(probe!)) throw Error('old nonce still visible'); + recovery = await openRecoveryContext( + host.owner, + policy, + qualification, + originalId, + publicOwner + ); + return recovery; + }, + close() { + if (nonceReader) stopInboxProbeNonceReader(nonceReader); + if (pool) closePrivatePool(pool); + recovery?.close(); + original?.close(); + if (publicOwner) closePublicRuntime(publicOwner.context); + closeBrowserDatabase(database); + host.close(); + } + }; +} + +// A parent-realm test extension host supports actual child-frame destruction and +// reload without persisting/exposing its random key. It is controlled evidence, +// not installed-extension or operator qualification. +export function createHostedProvider() { + const cryptoFixture = makeCryptoFixture(10050); + let keys = 0, + signs = 0, + encrypts = 0, + decrypts = 0, + mode: + | 'normal' + | 'hold_key' + | 'hold_decrypt' + | 'wrong_key' + | 'refuse_decrypt' + | 'wrong_decrypt' = 'normal', + waiting = '', + release: (() => void) | undefined; + const restorations = new Map<symbol, () => void>(); + function retain(off: () => void) { + const id = Symbol(); + restorations.set(id, off); + return () => { + off(); + restorations.delete(id); + }; + } + async function pause(stage: string) { + if (mode !== 'hold_' + stage) return; + waiting = stage; + await new Promise<void>((resolve) => { + release = resolve; + }); + waiting = ''; + release = undefined; + } + const cipher = { + encrypt: (target: string, wire: string) => { + encrypts++; + return Promise.resolve(cryptoFixture.encrypt(target, wire)); + }, + decrypt: async (target: string, wire: string) => { + decrypts++; + await pause('decrypt'); + if (mode === 'refuse_decrypt') + throw Error('controlled actual provider refusal'); + return mode === 'wrong_decrypt' + ? 'substituted plaintext' + : cryptoFixture.decrypt(target, wire); + } + }; + const provider = { + getPublicKey: async () => { + keys++; + await pause('key'); + return mode === 'wrong_key' ? 'f'.repeat(64) : cryptoFixture.owner; + }, + signEvent: (input: UnsignedEvent) => { + signs++; + return Promise.resolve(cryptoFixture.sign(input)); + }, + nip44: cipher + }; + Object.defineProperty(window, 'nostr', { + configurable: true, + value: provider + }); + return { + owner: cryptoFixture.owner, + preferenceWire: (origins: string[]) => + JSON.stringify( + cryptoFixture.sign({ + kind: 10050, + created_at: Math.floor(Date.now() / 1000), + tags: origins.map((origin) => ['relay', origin]), + content: '' + }) + ), + head: () => + JSON.stringify( + cryptoFixture.sign({ + kind: 10050, + created_at: Math.floor(Date.now() / 1000), + tags: [['relay', 'wss://inbox.example.org']], + content: '' + }) + ), + counts: () => ({ keys, signs, encrypts, decrypts }), + mode: (next: typeof mode) => { + mode = next; + }, + waiting: () => waiting, + settle: () => release?.(), + keyCallback(hit: number, callback: () => void | Promise<void>) { + const original = provider.getPublicKey.bind(provider); + let n = 0; + provider.getPublicKey = async () => { + if (++n === hit) await callback(); + return original(); + }; + return retain(() => { + provider.getPublicKey = original; + }); + }, + cipherGetter(callback: () => void) { + const descriptor = Object.getOwnPropertyDescriptor(provider, 'nip44')!; + Object.defineProperty(provider, 'nip44', { + configurable: true, + get() { + callback(); + return cipher; + } + }); + return retain(() => { + Object.defineProperty(provider, 'nip44', descriptor); + }); + }, + decryptCallback( + hit: number, + transform: (wire: string) => string | Promise<string> + ) { + const original = cipher.decrypt.bind(cipher), + descriptor = Object.getOwnPropertyDescriptor(cipher, 'decrypt')!; + let n = 0, + receivers = 0; + Object.defineProperty(cipher, 'decrypt', { + configurable: true, + value: async function ( + this: typeof cipher, + target: string, + wire: string + ) { + if (this !== cipher) throw Error('wrong actual SDK cipher receiver'); + receivers++; + const opened = await original(target, wire); + return ++n === hit ? transform(opened) : opened; + } + }); + return { + receivers: () => receivers, + restore: retain(() => { + Object.defineProperty(cipher, 'decrypt', descriptor); + }) + }; + }, + signSeal(wire: string, change: Record<string, unknown>) { + const seal = JSON.parse(wire) as UnsignedEvent; + return JSON.stringify( + cryptoFixture.sign({ + kind: seal.kind, + created_at: seal.created_at, + tags: seal.tags, + content: seal.content, + ...change + }) + ); + }, + close() { + for (const [id, off] of restorations) { + off(); + restorations.delete(id); + } + cryptoFixture.close(); + } + }; +} + +// Extension messages return data in the requesting document's realm. Direct +// parent objects fail the stock SDK's instanceof-Object event admission. Clone +// only the signed public event response; account key custody stays in the host. +export function installHostedProvider() { + type Port = { + getPublicKey(): Promise<string>; + signEvent(input: UnsignedEvent): Promise<Record<string, unknown>>; + nip44: { + encrypt(target: string, wire: string): Promise<string>; + decrypt(target: string, wire: string): Promise<string>; + }; + }; + const host = Reflect.get(window.parent, 'nostr') as Port; + const cipher = host.nip44; + Object.defineProperty(window, 'nostr', { + configurable: true, + value: { + getPublicKey: host.getPublicKey.bind(host), + signEvent: async (input: UnsignedEvent) => { + const signed = await host.signEvent(input); + return JSON.parse(JSON.stringify(signed)) as Record<string, unknown>; + }, + nip44: { + encrypt: cipher.encrypt.bind(cipher), + decrypt: cipher.decrypt.bind(cipher) + } + } + }); +} + +export async function prepareHostedOriginal( + context: Awaited<ReturnType<typeof openRecoveryContext>> +) { + const { repository, session, policy, access, operator } = context; + const reserved = await reserveInboxProbeIdentity( + repository, + session, + policy, + access, + operator, + 'reviewed_inbox_probe_reservation' + ); + if (!('identity' in reserved)) throw Error('actual hosted R0'); + const operation = captureInboxProbeSealOperation( + session, + reserved.identity, + 'reviewed_inbox_probe_seal' + ); + if (!operation) throw Error('actual hosted seal operation'); + const sealed = await buildInboxProbeSeal(operation); + if (!('seal' in sealed)) throw Error('actual hosted seal'); + const wrapped = buildInboxProbeGiftwrap( + sealed.seal, + 'reviewed_inbox_probe_wrap' + ); + if (!wrapped) throw Error('actual hosted wrap'); + const committed = await commitInboxProbe( + repository, + session, + wrapped, + 'reviewed_inbox_probe_commit' + ); + if (!('acknowledgement' in committed)) throw Error('actual hosted native R1'); + return inboxProbeAcknowledgementSnapshot(committed.acknowledgement)!.record; +} diff --git a/web/tests/e2e/inbox-probe-recovery.spec.ts b/web/tests/e2e/inbox-probe-recovery.spec.ts @@ -0,0 +1,1306 @@ +import { test, expect, type Page } from '@playwright/test'; +import { build } from 'vite'; +import { once } from 'node:events'; +import { fileURLToPath } from 'node:url'; +import { WebSocketServer, type WebSocket } from 'ws'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/inbox-probe-recovery.ts'; +declare global { + interface Window { + pr: typeof Fixture; + prFixture: Awaited<ReturnType<typeof Fixture.makeRecoveryFixture>>; + prFresh: Awaited<ReturnType<typeof Fixture.openRecoveryContext>>; + prPending?: Promise<unknown>; + prRelease?: () => void; + prRestore?: () => void; + prHosted?: ReturnType<typeof Fixture.createHostedProvider>; + prHostedContext?: Awaited<ReturnType<typeof Fixture.openRecoveryContext>>; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, + sockets: WebSocketServer, + endpoint: string, + bundle: string, + head = ''; +const physical = new Set<WebSocket>(), + archived = new Map<string, Record<string, unknown>>(), + frames: { origin: string; frame: unknown[] }[] = []; +test.beforeAll(async () => { + server = await createStaticHarness(); + sockets = new WebSocketServer({ + host: '127.0.0.1', + port: 0, + maxPayload: 65536 + }); + await once(sockets, 'listening'); + const address = sockets.address(); + if (!address || typeof address === 'string') + throw Error('actual loopback fixture'); + endpoint = 'ws://127.0.0.1:' + address.port; + sockets.on('connection', (socket, request) => { + physical.add(socket); + socket.on('close', () => physical.delete(socket)); + const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get( + 'origin' + )!; + socket.on('message', (bytes) => { + const raw = Buffer.isBuffer(bytes) + ? bytes + : Array.isArray(bytes) + ? Buffer.concat(bytes) + : Buffer.from(bytes); + const frame = JSON.parse(raw.toString()) as unknown[]; + frames.push({ origin, frame }); + if (frame[0] === 'REQ') { + const filter = frame[2] as { kinds?: number[]; ids?: string[] }; + if (filter.kinds?.includes(10050) && head) + socket.send(JSON.stringify(['EVENT', frame[1], JSON.parse(head)])); + if (filter.kinds?.includes(1059)) { + const event = archived.get(filter.ids?.[0] ?? ''); + if (event) socket.send(JSON.stringify(['EVENT', frame[1], event])); + } + socket.send(JSON.stringify(['EOSE', frame[1]])); + } else if (frame[0] === 'EVENT') { + const event = frame[1] as { id: string }; + archived.set(event.id, event); + socket.send(JSON.stringify(['OK', event.id, true, ''])); + } + }); + }); + const result = await build({ + configFile: false, + logLevel: 'silent', + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/inbox-probe-recovery.ts', import.meta.url) + ), + name: 'pr', + formats: ['iife'] + } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw Error('compiled actual source fixture'); + const chunks = output.output.filter((x) => x.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; +}); +test.afterAll(async () => { + for (const socket of sockets.clients) socket.terminate(); + await new Promise<void>((resolve) => sockets.close(() => resolve())); + await server.close(); +}); +test.beforeEach(async ({ page }) => { + await expect.poll(() => physical.size).toBe(0); + head = ''; + frames.length = 0; + archived.clear(); + await page.addInitScript( + ({ endpoint }) => { + const Native = window.WebSocket; + window.WebSocket = class extends Native { + constructor(url: string | URL, protocols?: string | string[]) { + const origin = new URL(String(url)).origin; + if ( + ![ + 'wss://discovery.example.org', + 'wss://inbox.example.org', + 'wss://peer.example.org', + 'wss://archive.example.org' + ].includes(origin) + ) + throw Error('unapproved fixture origin'); + super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols); + } + }; + }, + { endpoint } + ); + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + head = await page.evaluate(async () => { + window.prFixture = await window.pr.makeRecoveryFixture(); + return window.prFixture.preferenceWire(['wss://inbox.example.org']); + }); + await page.evaluate(async () => { + const f = window.prFixture; + await f.capture(); + if ( + (await f.reserve()).status !== 'reserved' || + (await f.prepare()) !== 'wrapped' || + (await f.commitOriginal()).status !== 'prepared' + ) + throw Error('actual cold stored original'); + }); +}); +test.afterEach(async ({ page }) => { + if (!page.isClosed()) + await page.evaluate(() => { + window.prRestore?.(); + window.prRelease?.(); + window.prHostedContext?.close(); + window.prHosted?.close(); + window.prFixture.close(); + }); +}); +async function fresh(page: Page) { + await page.evaluate(async () => { + window.prFresh = await window.prFixture.fresh(); + }); +} +function privateFrames() { + return frames.filter((x) => x.origin !== 'wss://discovery.example.org'); +} +async function originalReadback(page: Page) { + await page.evaluate(async () => { + const f = window.prFixture, + publication = await f.publish(); + if ( + publication.status !== 'accepted' || + (await f.append(publication)).status !== 'saved' + ) + throw Error('actual original B1'); + const readback = await f.read(); + if ( + readback.status !== 'readback' || + (await f.appendRead(readback)).status !== 'saved' + ) + throw Error('actual original B2'); + }); +} +test('genuine ordinary and C1 readers/proofs cannot cross into recovered-probe families', async ({ + page +}) => { + await originalReadback(page); + const result = await page.evaluate(async () => { + const f = window.prFixture, + nonce = await f.nonce(); + if (!('proof' in nonce)) throw Error('genuine current C1 proof'); + const id = f.snapshot()!.record.id; + const ordinary = window.pr.captureSelfRecoveryReader( + f.repository, + f.identity, + id, + 'reviewed_self_decryption' + )!; + const recovery = window.pr.captureInboxProbeRecoveryReader( + f.repository, + f.identity, + f.session, + f.policy, + f.controller()!, + f.qualification, + id, + 'reviewed_inbox_probe_recovery' + )!; + const before = f.counts(); + const c1Reader = await window.pr.recoverInboxProbe( + f.nonceReader()! as unknown as Parameters< + typeof window.pr.recoverInboxProbe + >[0] + ); + const ordinaryReader = await window.pr.recoverInboxProbe( + ordinary as unknown as Parameters<typeof window.pr.recoverInboxProbe>[0] + ); + const c1Proof = window.pr.recoveredInboxProbeBinding( + nonce.proof as unknown as Parameters< + typeof window.pr.recoveredInboxProbeBinding + >[0], + f.repository, + f.session, + f.controller()!, + f.policy, + f.qualification + ); + const noEffects = JSON.stringify(before) === JSON.stringify(f.counts()); + const recovered = await window.pr.recoverInboxProbe(recovery); + const wrongC1 = await window.pr.readInboxProbeNonce( + recovery as unknown as Parameters<typeof window.pr.readInboxProbeNonce>[0] + ); + return { + ordinaryGenuine: !!ordinary, + c1Reader, + ordinaryReader, + c1Proof: !!c1Proof, + noEffects, + recovery: recovered.status, + wrongC1 + }; + }); + expect(result).toEqual({ + ordinaryGenuine: true, + c1Reader: { status: 'invalid' }, + ordinaryReader: { status: 'invalid' }, + c1Proof: false, + noEffects: true, + recovery: 'recovered', + wrongC1: { status: 'invalid' } + }); +}); +test('genuine current C1 memory proof cannot replace actual original stored ciphertext decryption', async ({ + page +}) => { + await originalReadback(page); + const result = await page.evaluate(async () => { + const f = window.prFixture, + nonce = await f.nonce(); + if (!('proof' in nonce)) throw Error('genuine current C1 proof'); + const reader = window.pr.captureInboxProbeRecoveryReader( + f.repository, + f.identity, + f.session, + f.policy, + f.controller()!, + f.qualification, + f.snapshot()!.record.id, + 'reviewed_inbox_probe_recovery' + )!; + f.mode('wrong_decrypt'); + const before = await f.stored(), + result = await window.pr.recoverInboxProbe(reader); + return { + status: result.status, + same: JSON.stringify(before) === JSON.stringify(await f.stored()) + }; + }); + expect(result).toEqual({ status: 'mismatch', same: true }); +}); +for (const alias of ['whitespace', 'key-order']) + for (const phase of ['before', 'final-key']) + test(`physical ${alias} alias at ${phase} cannot pass canonical-only native comparison`, async ({ + page + }) => { + await fresh(page); + const result = await page.evaluate( + async ({ alias, phase }) => { + const f = window.prFixture, + r = window.prFresh, + row = (await f.stored()).find((x) => x.id === r.localId)!; + const decoded = window.pr.decodePrivateRecord( + row.wire, + row.owner, + row.id + ); + if (!decoded.ok) throw Error('original strict native row'); + const record = JSON.parse(row.wire) as Record<string, unknown>; + const wire = + alias === 'whitespace' + ? JSON.stringify(record, null, 1) + : JSON.stringify( + Object.fromEntries(Object.entries(record).reverse()) + ); + const alternate = window.pr.decodePrivateRecord( + wire, + row.owner, + row.id + ); + if ( + !alternate.ok || + window.pr.privateRecordWire(alternate.value, row.owner, row.id) !== + window.pr.privateRecordWire(decoded.value, row.owner, row.id) + ) + throw Error('actual canonical-equivalent physical alias'); + if (phase === 'before') await f.inject([{ ...row, wire }]); + else + window.prRestore = f.keyCallback(3, () => + f.inject([{ ...row, wire }]) + ); + const result = await r.recover(); + return { + status: result.status, + proof: !!r.binding(), + aliasRetained: + (await f.stored()).find((x) => x.id === r.localId)?.wire === wire + }; + }, + { alias, phase } + ); + expect(result.status).not.toBe('recovered'); + expect(result.proof).toBe(false); + expect(result.aliasRetained).toBe(true); + }); +test('actual B1/B2 then memory teardown recovers the immutable original with no ordinary send, new artifact, native growth or traffic', async ({ + page +}) => { + await page.evaluate(async () => { + const f = window.prFixture; + const pub = await f.publish(); + if (pub.status !== 'accepted' || (await f.append(pub)).status !== 'saved') + throw Error('actual B1'); + const read = await f.read(); + if ( + read.status !== 'readback' || + (await f.appendRead(read)).status !== 'saved' + ) + throw Error('actual B2'); + }); + await fresh(page); + const traffic = privateFrames().length; + const result = await page.evaluate(async () => { + const f = window.prFixture, + r = window.prFresh, + before = f.counts(), + rows = await f.stored(), + reader = r.capture()!, + repeat = r.capture(); + const inert = f.counts(), + receiver = f.decryptCallback(0, (wire) => wire); + const originalRandom = crypto.getRandomValues.bind(crypto), + originalUuid = crypto.randomUUID.bind(crypto); + let randomness = 0; + crypto.getRandomValues = () => { + randomness++; + throw Error('new recovery randomness'); + }; + crypto.randomUUID = () => { + randomness++; + throw Error('new recovery command'); + }; + let recovered: Awaited<ReturnType<typeof r.recover>>; + try { + recovered = await r.recover(reader); + } finally { + crypto.getRandomValues = originalRandom; + crypto.randomUUID = originalUuid; + } + const again = await r.recover(reader), + binding = r.binding(), + after = f.counts(); + return { + status: recovered.status, + again: again.status, + sameProof: + 'proof' in recovered && + 'proof' in again && + recovered.proof === again.proof, + sameReader: reader === repeat, + before, + inert, + after, + rowsSame: JSON.stringify(rows) === JSON.stringify(await f.stored()), + receivers: receiver.receivers(), + randomness, + binding: binding && { + command: binding.command, + rumorHash: binding.rumorHash, + eventId: binding.eventId, + keys: Object.keys(binding) + }, + oldNonceGone: !window.pr.inboxProbeRumorWire( + f.probeIdentity()!, + f.session + ), + readiness: window.pr.inboxAccessControllerSnapshot(r.access)?.readiness + }; + }); + expect(result.status).toBe('recovered'); + expect(result.again).toBe('recovered'); + expect(result.sameProof).toBe(true); + expect(result.sameReader).toBe(true); + expect(result.inert).toEqual(result.before); + expect(result.after.decrypts - result.before.decrypts).toBe(2); + expect(result.after.keys - result.before.keys).toBe(3); + expect(result.after.signs).toBe(result.before.signs); + expect(result.after.encrypts).toBe(result.before.encrypts); + expect(result.randomness).toBe(0); + expect(result.receivers).toBe(2); + expect(result.rowsSame).toBe(true); + expect(result.oldNonceGone).toBe(true); + expect(result.readiness).toBe('unavailable'); + expect(result.binding?.keys).not.toContain('rumorWire'); + expect(privateFrames()).toHaveLength(traffic); +}); +for (const bad of [ + 'review', + 'id', + 'repository', + 'identity', + 'session', + 'policy', + 'controller', + 'operator', + 'unconfigured', + 'unsupported', + 'copy' +]) + test(`inert recovery capture rejects ${bad} before provider or native work`, async ({ + page + }) => { + await fresh(page); + const result = await page.evaluate((bad) => { + const f = window.prFixture, + r = window.prFresh, + before = f.counts(); + let native = 0; + const original = Object.getOwnPropertyDescriptor( + IDBDatabase.prototype, + 'transaction' + )!.value as IDBDatabase['transaction']; + IDBDatabase.prototype.transaction = function ( + ...args: Parameters<IDBDatabase['transaction']> + ) { + native++; + return original.apply(this, args); + }; + let reader; + try { + reader = window.pr.captureInboxProbeRecoveryReader( + bad === 'repository' ? f.foreignRepository() : r.repository, + bad === 'identity' ? f.identity : r.identity, + bad === 'session' ? f.session : r.session, + bad === 'policy' ? f.copiedPolicy() : r.policy, + bad === 'controller' + ? f.controller()! + : bad === 'copy' + ? { ...r.access } + : r.access, + bad === 'operator' + ? ({} as typeof r.operator) + : bad === 'unconfigured' + ? f.operator(false, true) + : bad === 'unsupported' + ? f.operator(true) + : r.operator, + bad === 'id' ? 'not-original' : r.localId, + bad === 'review' ? true : 'reviewed_inbox_probe_recovery' + ); + } finally { + IDBDatabase.prototype.transaction = original; + } + return { admitted: !!reader, before, after: f.counts(), native }; + }, bad); + expect(result.admitted).toBe(false); + expect(result.after).toEqual(result.before); + expect(result.native).toBe(0); + }); +test('invalid controller/session/policy associations never retry actual retained failed private cleanup', async ({ + page +}) => { + const result = await page.evaluate(() => { + const f = window.prFixture; + let retries = 0; + const off = window.pr.subscribePrivateSessionClose(f.session, () => { + retries++; + throw Error('retained original cleanup'); + }); + window.pr.closePrivateSession(f.session); + const before = retries; + const fake = {} as Parameters< + typeof window.pr.inboxAccessConstructionBinding + >[0]; + const absent = window.pr.inboxAccessConstructionBinding( + fake, + f.session, + f.policy + ), + wrongPolicy = window.pr.inboxAccessConstructionBinding( + f.controller()!, + f.session, + f.copiedPolicy() + ), + wrongSession = window.pr.inboxAccessConstructionBinding( + f.controller()!, + fake as unknown as Parameters< + typeof window.pr.inboxAccessConstructionBinding + >[1], + f.policy + ); + const matching = window.pr.inboxAccessConstructionBinding( + f.controller()!, + f.session, + f.policy + ); + const wrongIdentity = {} as typeof f.identity; + const refused = window.pr.captureInboxProbeRecoveryReader( + f.repository, + wrongIdentity, + f.session, + f.policy, + f.controller()!, + f.qualification, + '11111111-1111-4111-8111-111111111111', + 'reviewed_inbox_probe_recovery' + ); + const correctIdentity = window.pr.captureInboxProbeRecoveryReader( + f.repository, + f.identity, + f.session, + f.policy, + f.controller()!, + f.qualification, + '11111111-1111-4111-8111-111111111111', + 'reviewed_inbox_probe_recovery' + ); + const after = retries, + retained = window.pr.privateSessionCleanupRequired(f.session); + off(); + window.pr.closePrivateSession(f.session); + return { + before, + after, + retained, + admitted: !!( + absent || + wrongPolicy || + wrongSession || + matching || + refused || + correctIdentity + ) + }; + }); + expect(result.before).toBeGreaterThan(0); + expect(result.after).toBe(result.before); + expect(result.retained).toBe(true); + expect(result.admitted).toBe(false); +}); +test('one selected original reader prevents second-command/reset and copied/cross-family capability admission', async ({ + page +}) => { + await fresh(page); + const result = await page.evaluate(async () => { + const r = window.prFresh, + reader = r.capture()!, + other = r.capture('reviewed_inbox_probe_recovery', crypto.randomUUID()); + const recovered = await r.recover(reader); + if (!('proof' in recovered)) throw Error('genuine recovered family'); + const copies = await window.pr.recoverInboxProbe({ ...reader }), + ordinary = window.pr.recoveredSelfEnvelopeSnapshot( + recovered.proof as unknown as Parameters< + typeof window.pr.recoveredSelfEnvelopeSnapshot + >[0] + ), + nonce = window.pr.inboxProbeNonceProofBinding( + recovered.proof as unknown as Parameters< + typeof window.pr.inboxProbeNonceProofBinding + >[0], + r.repository, + r.session, + r.policy + ), + copied = window.pr.recoveredInboxProbeBinding( + { ...recovered.proof }, + r.repository, + r.session, + r.access, + r.policy, + r.operator + ); + return { + other: !!other, + copies, + ordinary: !!ordinary, + nonce: !!nonce, + copied: !!copied + }; + }); + expect(result).toEqual({ + other: false, + copies: { status: 'invalid' }, + ordinary: false, + nonce: false, + copied: false + }); +}); +for (const mutation of [ + 'r0', + 'missing-self', + 'ordinary', + 'corrupt', + 'alias', + 'tail', + 'binding', + 'hash', + 'time', + 'disappeared' +]) + test(`actual native ${mutation} cannot substitute original recovery custody`, async ({ + page + }) => { + await fresh(page); + const result = await page.evaluate(async (mutation) => { + const f = window.prFixture, + r = window.prFresh, + row = (await f.stored()).find((x) => x.id === r.localId)!, + record = JSON.parse(row.wire) as Record<string, unknown>, + before = f.counts(); + if (mutation === 'r0') { + record.revision = 0; + record.self = null; + record.receipts = []; + } + if (mutation === 'missing-self') record.self = null; + if (mutation === 'ordinary') { + record.family = 'private_send_reservation'; + delete record.binding; + delete record.self; + delete record.receipts; + record.revision = 0; + record.peer = f.owner; + } + if (mutation === 'binding') + (record.binding as { preferenceId: string }).preferenceId = 'f'.repeat( + 64 + ); + if (mutation === 'hash') record.rumorHash = 'f'.repeat(64); + if (mutation === 'time') record.createdAt = Number(record.createdAt) + 1; + if (mutation === 'alias') + await f.inject([{ ...row, id: crypto.randomUUID() }]); + else if (mutation === 'tail') + await f.inject([ + { owner: row.owner, id: crypto.randomUUID(), wire: '{' } + ]); + else if (mutation === 'disappeared') await f.removeOriginal(); + else + await f.inject([ + { + ...row, + wire: mutation === 'corrupt' ? '{' : JSON.stringify(record) + } + ]); + const rows = await f.stored(), + recovered = await r.recover(); + return { + status: recovered.status, + before, + after: f.counts(), + rowsSame: JSON.stringify(rows) === JSON.stringify(await f.stored()), + proof: !!r.binding() + }; + }, mutation); + expect(result.status).not.toBe('recovered'); + expect(result.rowsSame).toBe(true); + expect(result.proof).toBe(false); + expect(result.after.signs).toBe(result.before.signs); + expect(result.after.encrypts).toBe(result.before.encrypts); + if (!['hash', 'time'].includes(mutation)) + expect(result.after.decrypts).toBe(result.before.decrypts); + }); +test('valid handwritten prior unknown/network labels permit only local decryption and confer no remote readiness', async ({ + page +}) => { + await page.evaluate(async () => { + const f = window.prFixture; + const result = await f.publish(); + await f.append(result); + }); + await fresh(page); + const result = await page.evaluate(async () => { + const f = window.prFixture, + r = window.prFresh, + row = (await f.stored()).find((x) => x.id === r.localId)!, + record = JSON.parse(row.wire) as { receipts: { status: string }[] }; + record.receipts[0].status = 'unknown'; + await f.inject([{ ...row, wire: JSON.stringify(record) }]); + const rows = await f.stored(), + result = await r.recover(); + return { + status: result.status, + same: JSON.stringify(rows) === JSON.stringify(await f.stored()), + readiness: window.pr.inboxAccessControllerSnapshot(r.access)?.readiness + }; + }); + expect(result).toEqual({ + status: 'recovered', + same: true, + readiness: 'unavailable' + }); +}); +for (const mode of ['wrong_key', 'refuse_decrypt', 'wrong_decrypt'] as const) + test(`actual provider ${mode} consumes the original action without a repeated prompt`, async ({ + page + }) => { + await fresh(page); + const result = await page.evaluate(async (mode) => { + const f = window.prFixture, + r = window.prFresh; + f.mode(mode); + const before = f.counts(), + first = await r.recover(), + after = f.counts(); + f.mode('normal'); + const again = await r.recover(); + return { + first: first.status, + again: again.status, + before, + after, + final: f.counts() + }; + }, mode); + expect(result.first).not.toBe('recovered'); + expect(result.again).not.toBe('recovered'); + expect(result.final).toEqual(result.after); + if (mode === 'wrong_key') + expect(result.after.decrypts).toBe(result.before.decrypts); + }); +for (const stage of ['key', 'decrypt'] as const) + for (const loss of [ + 'stop', + 'expire', + 'head', + 'controller', + 'private', + 'identity' + ] as const) + test(`pending real ${stage} ${loss} hides recovery and retains the actual shared occupied slot until settlement`, async ({ + page + }) => { + await fresh(page); + await page.evaluate((stage) => { + window.prFixture.mode(stage === 'key' ? 'hold_key' : 'hold_decrypt'); + window.prPending = window.prFresh.recover(); + }, stage); + await expect + .poll(() => page.evaluate(() => window.prFixture.waiting())) + .toBe(stage); + const result = await page.evaluate(async (loss) => { + const f = window.prFixture, + r = window.prFresh, + reader = r.reader()!; + if (loss === 'stop') window.pr.stopInboxProbeRecoveryReader(reader); + if (loss === 'expire') + window.pr.expireInboxProbeRecoveryReaderWait(reader); + if (loss === 'head') r.churnHead(); + if (loss === 'controller') + window.pr.closeInboxAccessController(r.access); + if (loss === 'private') window.pr.closePrivateSession(r.session); + if (loss === 'identity') window.pr.disconnectIdentity(r.identity); + const occupied = window.pr.extensionSchedulerSnapshot( + window.pr.browserExtensionScheduler()! + )?.state; + const busy = await window.pr.runExtensionAction( + window.pr.browserExtensionScheduler()!, + { owner: r.owner, session: Symbol(), operation: Symbol() }, + () => true, + () => Promise.resolve('foreign') + ); + f.mode('normal'); + f.settle(); + const result = await window.prPending; + const after = f.counts(); + const repeated = await r.recover(reader); + return { + occupied, + busy: busy.status, + result, + repeated: repeated.status, + unchanged: JSON.stringify(after) === JSON.stringify(f.counts()), + proof: !!r.binding(), + final: window.pr.extensionSchedulerSnapshot( + window.pr.browserExtensionScheduler()! + )?.state + }; + }, loss); + expect(result.occupied).toBe('active'); + expect(result.busy).toBe('busy'); + expect(result.result).not.toMatchObject({ status: 'recovered' }); + expect(result.repeated).not.toBe('recovered'); + expect(result.proof).toBe(false); + expect(result.unchanged).toBe(true); + expect(result.final).toBe('idle'); + }); +test('actual owner lock busy admits zero SDK calls and explicit same-reader execution recovers after release', async ({ + page +}) => { + await fresh(page); + await page.evaluate(() => { + const r = window.prFresh; + window.prPending = navigator.locks.request( + 'harvestcircle:owner:' + r.owner, + () => + new Promise<void>((resolve) => { + window.prRelease = resolve; + }) + ); + }); + await expect.poll(() => page.evaluate(() => !!window.prRelease)).toBe(true); + const first = await page.evaluate(async () => { + const f = window.prFixture, + r = window.prFresh, + reader = r.capture()!, + before = f.counts(), + result = await r.recover(reader); + return { + result, + equal: JSON.stringify(before) === JSON.stringify(f.counts()), + same: reader === r.capture() + }; + }); + expect(first).toEqual({ + result: { status: 'busy' }, + equal: true, + same: true + }); + await page.evaluate(async () => { + window.prRelease!(); + await window.prPending; + }); + expect( + await page.evaluate(async () => (await window.prFresh.recover()).status) + ).toBe('recovered'); +}); +test('actual shared scheduler busy permits one explicit original-operation run after release', async ({ + page +}) => { + await fresh(page); + await page.evaluate(() => { + window.prPending = window.pr.runExtensionAction( + window.pr.browserExtensionScheduler()!, + { owner: window.prFresh.owner, session: Symbol(), operation: Symbol() }, + () => true, + () => + new Promise<void>((resolve) => { + window.prRelease = resolve; + }) + ); + }); + await expect.poll(() => page.evaluate(() => !!window.prRelease)).toBe(true); + const result = await page.evaluate(async () => { + const f = window.prFixture, + r = window.prFresh, + before = f.counts(), + first = await r.recover(); + return { + first: first.status, + same: r.reader() === r.capture(), + equal: JSON.stringify(before) === JSON.stringify(f.counts()) + }; + }); + expect(result).toEqual({ first: 'busy', same: true, equal: true }); + await page.evaluate(async () => { + window.prRelease!(); + await window.prPending; + }); + expect( + await page.evaluate(async () => (await window.prFresh.recover()).status) + ).toBe('recovered'); +}); +for (const hit of [1, 2, 3]) + for (const loss of ['native', 'head', 'controller', 'private', 'identity']) + test(`actual fresh-key${hit} ${loss} mutation cannot precede a stale recovered proof`, async ({ + page + }) => { + await fresh(page); + const result = await page.evaluate( + async ({ hit, loss }) => { + const f = window.prFixture, + r = window.prFresh; + window.prRestore = f.keyCallback(hit, async () => { + if (loss === 'native') { + const row = (await f.stored()).find((x) => x.id === r.localId)!, + record = JSON.parse(row.wire) as { + binding: { preferenceId: string }; + }; + record.binding.preferenceId = 'f'.repeat(64); + await f.inject([{ ...row, wire: JSON.stringify(record) }]); + } + if (loss === 'head') r.churnHead(); + if (loss === 'controller') + window.pr.closeInboxAccessController(r.access); + if (loss === 'private') window.pr.closePrivateSession(r.session); + if (loss === 'identity') window.pr.disconnectIdentity(r.identity); + }); + const result = await r.recover(); + return { status: result.status, proof: !!r.binding() }; + }, + { hit, loss } + ); + expect(result.status).not.toBe('recovered'); + expect(result.proof).toBe(false); + }); +test('cipher getter scope loss preserves current identity and independent private session', async ({ + page +}) => { + await fresh(page); + const result = await page.evaluate(async () => { + const f = window.prFixture, + r = window.prFresh; + window.prRestore = f.cipherGetter(() => + window.pr.closeInboxAccessController(r.access) + ); + const before = f.counts(), + result = await r.recover(); + return { + status: result.status, + noDecrypt: before.decrypts === f.counts().decrypts, + identity: + window.pr.identityMessagingOwnership(r.identity)?.current() ?? false, + session: window.pr.privateSessionSnapshot(r.session)?.current ?? false + }; + }); + expect(result.status).not.toBe('recovered'); + expect(result.noDecrypt).toBe(true); + expect(result.identity).toBe(true); + expect(result.session).toBe(true); +}); +test('invalid fresh key never acquires the cipher getter', async ({ page }) => { + await fresh(page); + const result = await page.evaluate(async () => { + const f = window.prFixture, + r = window.prFresh; + let getters = 0; + window.prRestore = f.cipherGetter(() => { + getters++; + }); + f.mode('wrong_key'); + const before = f.counts(), + result = await r.recover(); + return { + status: result.status, + getters, + decrypts: f.counts().decrypts - before.decrypts + }; + }); + expect(result.status).not.toBe('recovered'); + expect(result.getters).toBe(0); + expect(result.decrypts).toBe(0); +}); +test('pending duplicate/reentrant capture keeps the same reader and admits no second SDK action', async ({ + page +}) => { + await fresh(page); + await page.evaluate(() => { + window.prFixture.mode('hold_decrypt'); + window.prPending = window.prFresh.recover(); + }); + await expect + .poll(() => page.evaluate(() => window.prFixture.waiting())) + .toBe('decrypt'); + const result = await page.evaluate(async () => { + const f = window.prFixture, + r = window.prFresh, + before = f.counts(), + reader = r.reader(), + duplicate = await r.recover(); + const same = reader === r.capture(), + inert = JSON.stringify(before) === JSON.stringify(f.counts()); + f.mode('normal'); + f.settle(); + const original = await window.prPending; + return { + duplicate: duplicate.status, + same, + inert, + original, + decrypts: f.counts().decrypts - before.decrypts + }; + }); + expect(result.duplicate).toBe('busy'); + expect(result.same).toBe(true); + expect(result.inert).toBe(true); + expect(result.original).toMatchObject({ status: 'recovered' }); + expect(result.decrypts).toBe(1); +}); +for (const loss of [ + 'stop', + 'expire', + 'head', + 'controller', + 'private', + 'identity' +]) + test(`genuine recovered proof revokes all original rumor visibility on ${loss}`, async ({ + page + }) => { + await fresh(page); + const result = await page.evaluate(async (loss) => { + const r = window.prFresh, + result = await r.recover(); + if (!('proof' in result)) throw Error('actual recovered proof'); + const visible = !!window.pr.recoveredInboxProbeRumorWire( + result.proof, + r.repository, + r.session, + r.access, + r.policy, + r.operator + ); + if (loss === 'stop') window.pr.stopInboxProbeRecoveryReader(r.reader()!); + if (loss === 'expire') + window.pr.expireInboxProbeRecoveryReaderWait(r.reader()!); + if (loss === 'head') r.churnHead(); + if (loss === 'controller') window.pr.closeInboxAccessController(r.access); + if (loss === 'private') window.pr.closePrivateSession(r.session); + if (loss === 'identity') window.pr.disconnectIdentity(r.identity); + return { + visible, + binding: !!r.binding(), + rumor: !!window.pr.recoveredInboxProbeRumorWire( + result.proof, + r.repository, + r.session, + r.access, + r.policy, + r.operator + ) + }; + }, loss); + expect(result).toEqual({ visible: true, binding: false, rumor: false }); + }); +for (const malformed of [ + 'id', + 'author', + 'time', + 'kind', + 'recipient', + 'prefix', + 'nonce', + 'extra', + 'duplicate', + 'numeric', + 'oversized' +]) + test(`actual SDK recovered diagnostic ${malformed} cannot mint original proof`, async ({ + page + }) => { + await fresh(page); + const result = await page.evaluate(async (malformed) => { + const f = window.prFixture, + r = window.prFresh; + const control = f.decryptCallback(2, (wire) => { + const rumor = JSON.parse(wire) as Record<string, unknown>; + if (malformed === 'id') rumor.id = 'f'.repeat(64); + if (malformed === 'author') rumor.pubkey = 'f'.repeat(64); + if (malformed === 'time') + rumor.created_at = Number(rumor.created_at) + 1; + if (malformed === 'kind') rumor.kind = 1; + if (malformed === 'recipient') rumor.tags = [['p', 'f'.repeat(64)]]; + if (malformed === 'prefix') + rumor.content = String(rumor.content).replace( + 'Harvestcircle', + 'Other' + ); + if (malformed === 'nonce') + rumor.content = String(rumor.content).slice(0, -1) + 'Z'; + if (malformed === 'extra') rumor.extra = true; + if (malformed === 'oversized') rumor.content = 'x'.repeat(8193); + const changed = JSON.stringify(rumor); + return malformed === 'duplicate' + ? changed.replace('"kind":14', '"kind":14,"kind":14') + : malformed === 'numeric' + ? changed.replace('"kind":14', '"kind":1.4e1') + : changed; + }); + window.prRestore = control.restore; + const before = await f.stored(), + result = await r.recover(); + return { + status: result.status, + proof: !!r.binding(), + same: JSON.stringify(before) === JSON.stringify(await f.stored()), + receivers: control.receivers() + }; + }, malformed); + expect(result.status).toBe('mismatch'); + expect(result.proof).toBe(false); + expect(result.same).toBe(true); + expect(result.receivers).toBe(2); + }); +for (const malformed of ['tags', 'kind', 'ciphertext']) + test(`actual independently signed inner seal ${malformed} is rejected`, async ({ + page + }) => { + await fresh(page); + const result = await page.evaluate(async (malformed) => { + const f = window.prFixture, + r = window.prFresh; + const control = f.decryptCallback(1, (wire) => + f.signSeal( + wire, + malformed === 'tags' + ? { tags: [['p', f.owner]] } + : malformed === 'kind' + ? { kind: 1 } + : { content: 'unsupported ciphertext' } + ) + ); + window.prRestore = control.restore; + const result = await r.recover(); + return { + status: result.status, + proof: !!r.binding(), + receivers: control.receivers() + }; + }, malformed); + expect(result.status).toBe('mismatch'); + expect(result.proof).toBe(false); + expect(result.receivers).toBe(1); + }); +for (const hit of [1, 2]) + for (const fault of ['before', 'after']) + test(`actual native readonly${hit} ${fault} abort refuses recovered authority`, async ({ + page + }) => { + await fresh(page); + const result = await page.evaluate( + async ({ hit, fault }) => { + const original = Object.getOwnPropertyDescriptor( + IDBIndex.prototype, + 'openCursor' + )!.value as IDBIndex['openCursor']; + let selected = 0, + aborts = 0; + IDBIndex.prototype.openCursor = function ( + ...args: Parameters<IDBIndex['openCursor']> + ) { + const request = original.apply(this, args); + if ( + this.objectStore.name === 'private_sends' && + this.objectStore.transaction.mode === 'readonly' && + ++selected === hit + ) { + const tx = this.objectStore.transaction; + if (fault === 'before') { + aborts++; + tx.abort(); + } else + request.addEventListener( + 'success', + () => { + aborts++; + tx.abort(); + }, + { once: true } + ); + } + return request; + }; + window.prRestore = () => { + IDBIndex.prototype.openCursor = original; + }; + const result = await window.prFresh.recover(); + return { + status: result.status, + aborts, + proof: !!window.prFresh.binding() + }; + }, + { hit, fault } + ); + expect(result.status).not.toBe('recovered'); + expect(result.aborts).toBe(1); + expect(result.proof).toBe(false); + }); +test('actual same-origin child reload recovers stored ciphertext through a fresh source realm and extension-host closure', async ({ + page +}) => { + await page.evaluate(() => window.prFixture.close()); + head = await page.evaluate(() => { + window.prHosted = window.pr.createHostedProvider(); + return window.prHosted.head(); + }); + const setup = await page.evaluate(() => { + const policyWire = JSON.stringify({ + schemaVersion: 1, + public: [ + { + origin: 'wss://discovery.example.org', + read: true, + write: true, + nip50: false + } + ], + inbox: [{ origin: 'wss://inbox.example.org', read: true, write: true }], + postingEnabled: true, + messagingEnabled: true, + operatorDenylist: [] + }); + const operatorWire = JSON.stringify({ + schemaVersion: 1, + revision: 1, + authority: 'source_fixture', + policyWire, + evidenceSha256: 'a'.repeat(64), + relays: [ + { + origin: 'wss://inbox.example.org', + auth: 'not_required', + recipientRead: 'supported', + namedArchiveAck: 'supported', + exactReadback: 'supported', + retention: 'operator_defined' + } + ] + }); + return { owner: window.prHosted!.owner, policyWire, operatorWire }; + }); + await page.evaluate((url) => { + const iframe = document.createElement('iframe'); + iframe.id = 'recovery-realm'; + iframe.src = url; + document.body.append(iframe); + }, server.url + '/search'); + const frame = await ( + await page.locator('#recovery-realm').elementHandle() + ).contentFrame(); + if (!frame) throw Error('actual same-origin child'); + await frame.waitForLoadState(); + await frame.addScriptTag({ content: bundle }); + const original = await frame.evaluate(async (setup) => { + window.pr.installHostedProvider(); + const policy = window.pr.validateRelayPolicy(setup.policyWire)!, + operator = window.pr.validateInboxOperatorQualification( + setup.operatorWire + )!; + window.prHostedContext = await window.pr.openRecoveryContext( + setup.owner, + policy, + operator, + crypto.randomUUID() + ); + const record = await window.pr.prepareHostedOriginal( + window.prHostedContext + ); + window.prHostedContext.close(); + return { + owner: record.owner, + id: record.id, + hash: record.rumorHash, + eventId: record.self!.eventId, + policyWire: setup.policyWire, + operatorWire: setup.operatorWire + }; + }, setup); + for (let cycle = 0; cycle < 2; cycle++) { + await frame.goto(server.url + '/search'); + await frame.addScriptTag({ content: bundle }); + const before = await page.evaluate(() => window.prHosted!.counts()); + const result = await frame.evaluate(async (setup) => { + window.pr.installHostedProvider(); + const policy = window.pr.validateRelayPolicy(setup.policyWire)!, + operator = window.pr.validateInboxOperatorQualification( + setup.operatorWire + )!; + window.prFresh = await window.pr.openRecoveryContext( + setup.owner, + policy, + operator, + setup.id + ); + const result = await window.prFresh.recover(), + binding = window.prFresh.binding(); + const output = { + status: result.status, + command: binding?.command, + hash: binding?.rumorHash, + eventId: binding?.eventId + }; + window.prFresh.close(); + return output; + }, original); + expect(result).toEqual({ + status: 'recovered', + command: original.id, + hash: original.hash, + eventId: original.eventId + }); + const after = await page.evaluate(() => window.prHosted!.counts()); + expect(after.signs).toBe(before.signs); + expect(after.encrypts - before.encrypts).toBe(1); // Actual fresh capability probe; recovery creates no artifact. + expect(after.decrypts - before.decrypts).toBe(3); // Fresh capability probe plus original two-layer recovery. + } +}); diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -1976,8 +1976,8 @@ import { auditOutput } from '../../tools/check-output.mjs'; 'src/lib/nostr/giftwrap-builder.ts', 'src/lib/config/inbox-operators.ts', 'src/lib/persistence/private-sends.ts', - // CR008-S4C1: both current admissions bind the actual shared guarded - // self reader and distinct original-observation nonce proof owner. + // CR008-S4C2A: current admissions bind the shared guarded self + // engine, distinct persisted-probe recovery and controller admission. 'src/lib/nostr/self-recovery-reader.ts', 'src/lib/config/operation-flags.ts', 'src/lib/nostr/private-pool.ts', diff --git a/web/tests/unit/inbox-probe-recovery.test.ts b/web/tests/unit/inbox-probe-recovery.test.ts @@ -0,0 +1,174 @@ +import { afterEach, expect, it, vi } from 'vitest'; +import { getEventHash, type UnsignedEvent } from 'applesauce-core/helpers'; +import type { IdentitySession } from '../../src/lib/runtime/identity-session.ts'; +import type { PrivateSession } from '../../src/lib/runtime/private-session.ts'; +import type { PrivateStorageRepository } from '../../src/lib/persistence/private-storage.ts'; +import type { RelayPolicy } from '../../src/lib/config/relays.ts'; +import type { InboxOperatorQualification } from '../../src/lib/config/inbox-operators.ts'; +import type { InboxAccessController } from '../../src/lib/messaging/inbox-access-controller.ts'; +import type { + InboxProbeRecoveryReader, + RecoveredInboxProbe, + InboxProbeNonceProof +} from '../../src/lib/nostr/self-recovery-reader.ts'; +import { inboxProbeRumorMatches } from '../../src/lib/nostr/inbox-access.ts'; + +afterEach(() => vi.unstubAllGlobals()); +const owner = + '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798', + time = 1700000000; +const event: UnsignedEvent = { + pubkey: owner, + created_at: time, + kind: 14, + tags: [['p', owner]], + content: 'Harvestcircle private inbox access check v1: ' + 'b'.repeat(64) +}; +const hash = getEventHash(event), + raw = JSON.stringify({ id: hash, ...event }); +it('the canonical pure diagnostic validator admits only exact original own hash/time/nonce', () => { + expect(inboxProbeRumorMatches(raw, owner, hash, time)).toBe(true); + expect(inboxProbeRumorMatches(raw, owner.toUpperCase(), hash, time)).toBe( + false + ); + for (const malformed of [ + undefined, + null, + false, + {}, + raw + ' ', + '{', + raw.replace('"kind":14', '"kind":1.4e1'), + raw.replace('"kind":14', '"kind":14,"kind":14'), + raw.replace('"id":', '"extra":0,"id":'), + raw.replace('"content":', '"\\u0063ontent":') + ]) + expect(inboxProbeRumorMatches(malformed, owner, hash, time)).toBe(false); + for (const change of [ + { kind: 1 }, + { pubkey: 'c'.repeat(64) }, + { created_at: time + 1 }, + { tags: [] }, + { tags: [['p', 'c'.repeat(64)]] }, + { + tags: [ + ['p', owner], + ['p', owner] + ] + }, + { content: 'ordinary message' }, + { content: event.content + 'b' }, + { content: event.content.slice(0, -1) + 'B' }, + { content: 'x'.repeat(8193) } + ]) { + const altered = { ...event, ...change }; + const id = getEventHash(altered); + expect( + inboxProbeRumorMatches( + JSON.stringify({ id, ...altered }), + owner, + id, + time + ) + ).toBe(false); + } + for (const bad of [ + -1, + 1.5, + Number.MAX_SAFE_INTEGER + 1, + NaN, + Infinity, + String(time), + null + ]) + expect(inboxProbeRumorMatches(raw, owner, hash, bad)).toBe(false); + for (const bad of ['A'.repeat(64), 'c'.repeat(64), 'a'.repeat(63), null]) + expect(inboxProbeRumorMatches(raw, owner, bad, time)).toBe(false); +}); +for (const browser of [false, true]) + it(`cold ${browser ? 'browser-shaped' : 'SSR'} recovery rejects fabricated families before effects`, async () => { + vi.resetModules(); + let effects = 0; + const trap = () => { + effects++; + throw Error('unadmitted effect'); + }; + if (browser) { + vi.stubGlobal('window', { + get nostr() { + return trap(); + } + }); + vi.stubGlobal('navigator', { + get locks() { + return trap(); + } + }); + vi.stubGlobal('WebSocket', trap); + vi.stubGlobal('indexedDB', { open: trap }); + } + const m = await import('../../src/lib/nostr/self-recovery-reader.ts'); + const repository = {} as PrivateStorageRepository, + identity = {} as IdentitySession, + session = {} as PrivateSession, + policy = {} as RelayPolicy, + operator = {} as InboxOperatorQualification; + for (const fake of [ + undefined, + null, + 0, + false, + '', + Symbol(), + {}, + { current: () => true, nonce_verified: true }, + { status: 'recovered', proof: {} } + ]) { + expect( + m.captureInboxProbeRecoveryReader( + repository, + identity, + session, + policy, + fake as InboxAccessController, + operator, + '11111111-1111-4111-8111-111111111111', + 'reviewed_inbox_probe_recovery' + ) + ).toBeUndefined(); + expect( + await m.recoverInboxProbe(fake as InboxProbeRecoveryReader) + ).toEqual({ status: 'invalid' }); + expect( + m.recoveredInboxProbeBinding( + fake as RecoveredInboxProbe, + repository, + session, + fake as InboxAccessController, + policy, + operator + ) + ).toBeUndefined(); + expect( + m.recoveredInboxProbeRumorWire( + fake as RecoveredInboxProbe, + repository, + session, + fake as InboxAccessController, + policy, + operator + ) + ).toBeUndefined(); + expect( + m.inboxProbeNonceProofBinding( + fake as InboxProbeNonceProof, + repository, + session, + policy + ) + ).toBeUndefined(); + m.stopInboxProbeRecoveryReader(fake as InboxProbeRecoveryReader); + m.expireInboxProbeRecoveryReaderWait(fake as InboxProbeRecoveryReader); + } + expect(effects).toBe(0); + }); diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -317,7 +317,7 @@ async function operationalFlagsAdmission(web) { 'src/lib/messaging/inbox-setup-operation.ts': '245c6ce88b146dc731e7ace4f16dc9b5002a87a997f5568e4811b0c4a2daf035', 'src/lib/nostr/self-recovery-reader.ts': - '806230d8082a48b9c2117a16060aff50312be270348d7b8c5b93d6d6368d31a1', + '51758a11383ca5851f16d99628470cef333afbdc37e794e25f9891762c531b8b', 'src/lib/nostr/private-publisher.ts': '2f939dda3504b760dbf3758632cda6ce38d3e16c6d142b814e40a0e295a77d90', 'src/lib/nostr/private-pool.ts': @@ -327,13 +327,13 @@ async function operationalFlagsAdmission(web) { 'src/lib/persistence/inbox-probes.ts': 'b4d3089bcf08a5c9ac3a99dfcf8e2c2e2160a2c8996c19fccb2670614f7b4d7a', 'src/lib/nostr/inbox-access.ts': - 'd39f218b66fb51833e962b20152a2df81adf3097ba434a4cf2172ee4a7c8e3bc', + '8a58978f3b535348165bc66f2b773e69a08f39a4a5741fb1d59ba546054aa1ce', 'src/lib/nostr/seal-builder.ts': '3ccc967cc348e63857243ff6f0302c1a68da2afe85ca2c37e00d5a894785fc53', 'src/lib/nostr/giftwrap-builder.ts': 'faf54dd80a0995ac94b4b994d3cfd015516e5e201a1fbb6340e13c836ce49e98', 'src/lib/messaging/inbox-access-controller.ts': - '103c22b4cd721f7e3371ff887f4e7ca5df6a535688b9e9d0c67241db21430f9a', + '2e0d551f1e373603422cd6ad6d17bc2f291b205fbcca9b2a3420649b1cd74975', 'src/lib/messaging/inbox-setup-view.ts': 'e85238d20f1bbcb23599b36e67910f3df784efa43f0fa0b0b7f3da7e7fd33c79', 'src/lib/messaging/inbox-setup.ts': @@ -595,7 +595,7 @@ async function privacyDataAdmission(web) { 'src/lib/messaging/inbox-list.ts': '9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5', 'src/lib/nostr/self-recovery-reader.ts': - '806230d8082a48b9c2117a16060aff50312be270348d7b8c5b93d6d6368d31a1', + '51758a11383ca5851f16d99628470cef333afbdc37e794e25f9891762c531b8b', 'src/lib/nostr/private-publisher.ts': '2f939dda3504b760dbf3758632cda6ce38d3e16c6d142b814e40a0e295a77d90', 'src/lib/nostr/private-pool.ts': @@ -605,13 +605,13 @@ async function privacyDataAdmission(web) { 'src/lib/persistence/inbox-probes.ts': 'b4d3089bcf08a5c9ac3a99dfcf8e2c2e2160a2c8996c19fccb2670614f7b4d7a', 'src/lib/nostr/inbox-access.ts': - 'd39f218b66fb51833e962b20152a2df81adf3097ba434a4cf2172ee4a7c8e3bc', + '8a58978f3b535348165bc66f2b773e69a08f39a4a5741fb1d59ba546054aa1ce', 'src/lib/nostr/seal-builder.ts': '3ccc967cc348e63857243ff6f0302c1a68da2afe85ca2c37e00d5a894785fc53', 'src/lib/nostr/giftwrap-builder.ts': 'faf54dd80a0995ac94b4b994d3cfd015516e5e201a1fbb6340e13c836ce49e98', 'src/lib/messaging/inbox-access-controller.ts': - '103c22b4cd721f7e3371ff887f4e7ca5df6a535688b9e9d0c67241db21430f9a', + '2e0d551f1e373603422cd6ad6d17bc2f291b205fbcca9b2a3420649b1cd74975', 'src/lib/messaging/inbox-setup-view.ts': '4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84', 'src/lib/messaging/inbox-sync.ts':