app

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

commit c434293440106d19b73e8b8705f5a945602713b2
parent f67de70481779c3396f987637a334f146dc3de76
Author: triesap <tyson@radroots.org>
Date:   Thu,  8 Oct 2026 23:34:18 +0000

messages: resume interrupted encrypted preparation explicitly (HCP-083)

- Authenticate stored self ciphertext through the guarded SDK scheduler.
- Restore original command and rumor without regeneration or silent recreation.
- Finish only missing peer preparation and retain already paired artifacts.
- Verify actual reload recovery with shared bounds and slow-host test allowances.

Diffstat:
Mweb/playwright.config.ts | 1+
Mweb/src/lib/config/budgets.ts | 2++
Mweb/src/lib/messaging/envelope-preparation.ts | 23+++++++++++++++++++----
Mweb/src/lib/messaging/prepare-send.ts | 7+++++--
Aweb/src/lib/messaging/resume-preparation.ts | 297+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/messaging/rumor-plan.ts | 35+++++++++++++++++++++++++++++++++++
Mweb/src/lib/messaging/send-identity.ts | 54++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/src/lib/nostr/self-recovery-reader.ts | 345+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/nostr/verify-outbound-envelope.ts | 72+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
Mweb/src/lib/persistence/private-sends.ts | 13++++++++++++-
Aweb/tests/e2e/harness/resume-preparation.ts | 404+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/resume-preparation.spec.ts | 520+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/resume-preparation.test.ts | 50++++++++++++++++++++++++++++++++++++++++++++++++++
13 files changed, 1815 insertions(+), 8 deletions(-)

diff --git a/web/playwright.config.ts b/web/playwright.config.ts @@ -7,6 +7,7 @@ export default defineConfig({ workers: 1, retries: 0, timeout: 120_000, + expect: { timeout: 120_000 }, use: { browserName: 'chromium', headless: true, serviceWorkers: 'block' }, reporter: 'list' }); diff --git a/web/src/lib/config/budgets.ts b/web/src/lib/config/budgets.ts @@ -10,6 +10,8 @@ export const RELAY_BUDGETS = Object.freeze({ // Full history/live coordination has separate owners. These are logical // post-SDK-parse limits, not browser WebSocket allocation guarantees. export const PRIVATE_TRANSPORT_BUDGETS = Object.freeze({ + rumorBytes: 8192, + sealBytes: 16384, requestedPerRelay: 200, deliveries: 500, processedBytes: 8388608, diff --git a/web/src/lib/messaging/envelope-preparation.ts b/web/src/lib/messaging/envelope-preparation.ts @@ -24,7 +24,7 @@ declare const pairBrand: unique symbol; export type EnvelopePreparation = Readonly<{ [pairBrand]: true }>; type Role = 'self' | 'peer'; type Completed = Readonly<{ - operation: PrivateSealOperation; + operation?: PrivateSealOperation; proof: VerifiedOutboundEnvelope; }>; export type EnvelopePreparationResult = Readonly<{ @@ -59,7 +59,8 @@ const pairs = new WeakMap<EnvelopePreparation, Controller>(); export function captureEnvelopePreparation( session: IdentitySession, reserved: ReservedSendIdentity, - review: unknown + review: unknown, + recoveredSelf?: VerifiedOutboundEnvelope ): EnvelopePreparation | undefined { if (review !== 'reviewed_envelope_pair') return undefined; const inputRecord = reservedSendSnapshot(reserved), @@ -82,6 +83,20 @@ export function captureEnvelopePreparation( let self: Completed | undefined, peer: Completed | undefined, active: PrivateSealOperation | undefined; + if (recoveredSelf) { + const original = verifiedOutboundSnapshot(recoveredSelf); + if ( + !original || + original.role !== 'self' || + original.destination !== record.owner || + original.owner !== record.owner || + original.peer !== record.peer || + original.command !== record.id || + original.rumorHash !== record.rumorHash + ) + return undefined; + self = { proof: recoveredSelf }; + } let busy = false, generation = 0, unsubscribe = () => {}; @@ -98,8 +113,8 @@ export function captureEnvelopePreparation( if (!retained) return; retained = undefined; stop(false); - if (self) stopPrivateSeal(self.operation); - if (peer) stopPrivateSeal(peer.operation); + if (self?.operation) stopPrivateSeal(self.operation); + if (peer?.operation) stopPrivateSeal(peer.operation); self = undefined; peer = undefined; unsubscribe(); diff --git a/web/src/lib/messaging/prepare-send.ts b/web/src/lib/messaging/prepare-send.ts @@ -7,6 +7,7 @@ import { reservedSendSnapshot, type ReservedSendIdentity } from './send-identity.ts'; +import type { VerifiedOutboundEnvelope } from '../nostr/verify-outbound-envelope.ts'; import { captureEnvelopePreparation, prepareEnvelopeRole, @@ -99,7 +100,8 @@ export function captureSelfRecoveryPreparation( repository: PrivateStorageRepository, session: IdentitySession, reserved: ReservedSendIdentity, - review: unknown + review: unknown, + recoveredSelf?: VerifiedOutboundEnvelope ): SelfRecoveryPreparation | undefined { if (typeof window === 'undefined' || review !== 'reviewed_self_recovery') return undefined; @@ -114,7 +116,8 @@ export function captureSelfRecoveryPreparation( const pairInput = captureEnvelopePreparation( session, reserved, - 'reviewed_envelope_pair' + 'reviewed_envelope_pair', + recoveredSelf ); if (!pairInput) return undefined; const record = recordInput, diff --git a/web/src/lib/messaging/resume-preparation.ts b/web/src/lib/messaging/resume-preparation.ts @@ -0,0 +1,297 @@ +import { canonicalLocalId } from '../private-handles.ts'; +import { + identityMessagingOwnership, + subscribeIdentityInvalidation, + type IdentitySession +} from '../runtime/identity-session.ts'; +import { + loadPrivateRecord, + type PrivateStorageRepository +} from '../persistence/private-storage.ts'; +import { privateRecordWire } from '../persistence/private-records.ts'; +import { + captureSelfRecoveryReader, + readSelfRecoveryEnvelope, + recoveredSelfEnvelopeSnapshot, + stopSelfRecoveryReader, + expireSelfRecoveryReaderWait, + type SelfRecoveryReader, + type SelfRecoveryReadResult +} from '../nostr/self-recovery-reader.ts'; +import { + restoreRecoveredRumor, + rumorPlanSnapshot, + stopRumorPlan, + type RumorPlan +} from './rumor-plan.ts'; +import { restoreRecoveredSendIdentity } from './send-identity.ts'; +import { verifyRecoveredSelfEnvelope } from '../nostr/verify-outbound-envelope.ts'; +import { + captureSelfRecoveryPreparation, + prepareSelfRecovery, + preparePairedDelivery, + stopSelfRecoveryPreparation, + type SelfRecoveryPreparation, + type PairedDeliveryContext, + type PairedDeliveryPreparationResult +} from './prepare-send.ts'; +declare const resumeBrand: unique symbol; +export type ResumePreparation = Readonly<{ [resumeBrand]: true }>; +export type ResumePreparationResult = Readonly<{ + status: + | SelfRecoveryReadResult['status'] + | PairedDeliveryPreparationResult['status'] + | 'already_prepared'; +}>; +type Snapshot = Readonly<{ + owner: string; + command: string; + state: + | 'unsaved' + | 'recovering' + | 'recovered' + | 'prepared' + | 'lost' + | 'needs_action'; + busy: boolean; + copy: string; + peer?: string; + rumorHash?: string; + createdAt?: number; +}>; +type Controller = { + run( + context: PairedDeliveryContext | undefined, + review: unknown + ): Promise<ResumePreparationResult>; + snapshot(): Snapshot | undefined; + rumor(): RumorPlan | undefined; + stop(expired: boolean): void; +}; +const resumes = new WeakMap<ResumePreparation, Controller>(); +// Explicit memory-only recovery workflow. Capture/render performs no IO or +// extension job; actual Resume cannot recreate lost ciphertext or send a relay +// event. Original authenticated command/hash/time survive memory cache loss. +export function captureResumePreparation( + repository: PrivateStorageRepository, + session: IdentitySession, + localId: unknown, + review: unknown +): ResumePreparation | undefined { + if (typeof window === 'undefined' || review !== 'reviewed_private_resume') + return undefined; + const inputId = canonicalLocalId(localId), + inputOwnership = identityMessagingOwnership(session); + if (!inputId || !inputOwnership?.current()) return undefined; + const id = inputId, + ownership = inputOwnership; + let active = true, + busy = false, + generation = 0, + state: Snapshot['state'] = 'unsaved', + reader: SelfRecoveryReader | undefined, + plan: RumorPlan | undefined, + preparation: SelfRecoveryPreparation | undefined, + alreadyPaired = false, + peerOnly = false, + originalWire: string | undefined, + unsubscribe = () => {}; + function stop(expired: boolean) { + if (!active) return; + active = false; + generation++; + if (reader) { + if (expired) expireSelfRecoveryReaderWait(reader); + else stopSelfRecoveryReader(reader); + } + if (preparation) stopSelfRecoveryPreparation(preparation); + if (plan) stopRumorPlan(plan); + reader = undefined; + preparation = undefined; + plan = undefined; + originalWire = undefined; + unsubscribe(); + unsubscribe = () => {}; + } + function current() { + if (!active || !ownership.current() || (plan && !rumorPlanSnapshot(plan))) { + stop(false); + return false; + } + return true; + } + function snapshot(): Snapshot | undefined { + if (!current()) return undefined; + const rumor = plan && rumorPlanSnapshot(plan); + return { + owner: ownership.owner, + command: id, + state, + busy, + copy: + state === 'lost' + ? 'Encrypted recovery evidence was lost. This message cannot be silently recreated.' + : state === 'needs_action' + ? 'Encrypted recovery needs your review; no message was sent.' + : rumor + ? 'Original encrypted message recovered in this browser; no delivery is claimed.' + : 'Resume is required to decrypt stored recovery evidence.', + ...(rumor + ? { peer: rumor.peer, rumorHash: rumor.id, createdAt: rumor.createdAt } + : {}) + }; + } + async function run( + context: PairedDeliveryContext | undefined, + reviewed: unknown + ): Promise<ResumePreparationResult> { + if (reviewed !== 'reviewed_private_resume') return { status: 'invalid' }; + if (!current()) return { status: 'stopped' }; + if (busy) return { status: 'busy' }; + busy = true; + const attempt = generation, + admitted = () => current() && generation === attempt; + try { + if (!plan) { + state = 'recovering'; + reader = captureSelfRecoveryReader( + repository, + session, + id, + 'reviewed_self_decryption' + ); + if (!reader) { + state = 'needs_action'; + return { status: 'stopped' }; + } + const recovered = await readSelfRecoveryEnvelope(reader); + if (!admitted()) return { status: 'stopped' }; + if (recovered.status !== 'recovered') { + state = + recovered.status === 'lost_evidence' ? 'lost' : 'needs_action'; + stopSelfRecoveryReader(reader); + reader = undefined; + return { status: recovered.status }; + } + const source = recoveredSelfEnvelopeSnapshot(recovered.envelope); + plan = restoreRecoveredRumor(session, recovered.envelope); + const reserved = + plan && + restoreRecoveredSendIdentity(session, recovered.envelope, plan), + proof = + reserved && + verifyRecoveredSelfEnvelope( + reserved, + recovered.envelope, + 'reviewed_recovered_self' + ); + if (!source || !plan || !reserved || !proof || !admitted()) { + stop(false); + return { status: 'stopped' }; + } + originalWire = source.storedWire; + alreadyPaired = + !!source.record.peerArtifact && !!source.record.deliveryPlan; + peerOnly = !!source.record.peerArtifact && !source.record.deliveryPlan; + preparation = captureSelfRecoveryPreparation( + repository, + session, + reserved, + 'reviewed_self_recovery', + proof + ); + if (!preparation || !admitted()) { + stop(false); + return { status: 'stopped' }; + } + } + if (!preparation || !admitted()) return { status: 'stopped' }; + if (alreadyPaired || peerOnly) { + const stored = await loadPrivateRecord(repository, 'private_sends', id); + if (!admitted()) return { status: 'stopped' }; + if ( + !stored.ok || + privateRecordWire(stored.value, ownership.owner, id) !== originalWire + ) { + state = stored.ok + ? 'needs_action' + : stored.reason === 'invalid_record' + ? 'lost' + : 'needs_action'; + if (plan) stopRumorPlan(plan); + plan = undefined; + stopSelfRecoveryPreparation(preparation); + preparation = undefined; + if (reader) stopSelfRecoveryReader(reader); + reader = undefined; + return { + status: stored.ok + ? 'conflict' + : stored.reason === 'invalid_record' + ? 'lost_evidence' + : stored.reason + }; + } + state = 'recovered'; + return { + status: alreadyPaired ? 'already_prepared' : 'review_required' + }; + } + const saved = await prepareSelfRecovery( + preparation, + 'reviewed_self_recovery' + ); + if (!admitted()) return { status: 'stopped' }; + if (!['saved', 'existing', 'reconciled'].includes(saved.status)) { + state = 'needs_action'; + return { status: saved.status }; + } + state = 'recovered'; + if (!context) return { status: 'recovered' }; + const paired = await preparePairedDelivery( + preparation, + context, + 'reviewed_pair_preparation' + ); + if (!admitted()) return { status: 'stopped' }; + state = paired.status === 'prepared' ? 'prepared' : 'needs_action'; + return { status: paired.status }; + } catch { + state = 'needs_action'; + return { status: admitted() ? 'unavailable' : 'stopped' }; + } finally { + busy = false; + } + } + const token = Object.freeze({}) as ResumePreparation; + resumes.set(token, { + run, + snapshot, + rumor: () => (current() ? plan : undefined), + stop + }); + unsubscribe = subscribeIdentityInvalidation(session, () => stop(false)); + return current() ? token : undefined; +} +export function resumeEncryptedPreparation( + token: ResumePreparation, + context: PairedDeliveryContext | undefined, + review: unknown +): Promise<ResumePreparationResult> { + return ( + resumes.get(token)?.run(context, review) ?? + Promise.resolve({ status: 'invalid' }) + ); +} +export function resumePreparationSnapshot(token: ResumePreparation) { + return resumes.get(token)?.snapshot(); +} +export function resumeRecoveredRumor(token: ResumePreparation) { + return resumes.get(token)?.rumor(); +} +export function stopResumePreparation(token: ResumePreparation): void { + resumes.get(token)?.stop(false); +} +export function expireResumePreparationWait(token: ResumePreparation): void { + resumes.get(token)?.stop(true); +} diff --git a/web/src/lib/messaging/rumor-plan.ts b/web/src/lib/messaging/rumor-plan.ts @@ -6,6 +6,10 @@ import { type IdentitySession } from '../runtime/identity-session.ts'; import { buildEnquiryMessage, type EnquiryContext } from './enquiry-context.ts'; +import { + recoveredSelfEnvelopeSnapshot, + type RecoveredSelfEnvelope +} from '../nostr/self-recovery-reader.ts'; declare const rumorBrand: unique symbol; export type RumorPlan = Readonly<{ readonly [rumorBrand]: true }>; export type RumorPlanSnapshot = Readonly<{ @@ -96,6 +100,37 @@ export function captureReplyRumor( observedTime ); } +// Historical time/hash/wire are admitted only by actual authenticated SDK +// recovery. This creates no new intent, reservation, event or persistent body. +export function restoreRecoveredRumor( + session: IdentitySession, + recovered: RecoveredSelfEnvelope +): RumorPlan | undefined { + const ownership = identityMessagingOwnership(session), + snapshot = recoveredSelfEnvelopeSnapshot(recovered); + if ( + !ownership?.current() || + !snapshot || + snapshot.record.owner !== ownership.owner + ) + return undefined; + const token = Object.freeze({}) as RumorPlan; + const current = () => + ownership.current() && !!recoveredSelfEnvelopeSnapshot(recovered); + const unsubscribe = subscribeIdentityInvalidation(session, () => + stopRumorPlan(token) + ); + plans.set(token, { + owner: snapshot.record.owner, + peer: snapshot.record.peer, + id: snapshot.record.rumorHash, + createdAt: snapshot.record.createdAt, + wire: snapshot.rumorWire, + current, + unsubscribe + }); + return current() ? token : undefined; +} export function rumorPlanSnapshot( plan: RumorPlan ): RumorPlanSnapshot | undefined { diff --git a/web/src/lib/messaging/send-identity.ts b/web/src/lib/messaging/send-identity.ts @@ -6,6 +6,10 @@ import { } from '../runtime/identity-session.ts'; import { rumorPlanSnapshot, type RumorPlan } from './rumor-plan.ts'; import { + recoveredSelfEnvelopeSnapshot, + type RecoveredSelfEnvelope +} from '../nostr/self-recovery-reader.ts'; +import { privateSendReservationOwner, reservePrivateSendReservation, type PrivateSendReservationRepository, @@ -102,6 +106,56 @@ export function reservedSendSnapshot( const value = identities.get(identity); return value?.current() ? { ...value.record } : undefined; } +// Restore the original actual command from authenticated stored self evidence; +// never re-reserve it using the current clock or a detached caller hash. +export function restoreRecoveredSendIdentity( + session: IdentitySession, + recovered: RecoveredSelfEnvelope, + plan: RumorPlan +): ReservedSendIdentity | undefined { + const snapshot = recoveredSelfEnvelopeSnapshot(recovered), + ownership = identityMessagingOwnership(session), + rumor = rumorPlanSnapshot(plan); + if ( + !snapshot || + !ownership?.current() || + !rumor || + ownership.owner !== snapshot.record.owner || + rumor.owner !== snapshot.record.owner || + rumor.peer !== snapshot.record.peer || + rumor.id !== snapshot.record.rumorHash || + rumor.createdAt !== snapshot.record.createdAt || + rumor.wire !== snapshot.rumorWire + ) + return undefined; + const record: PrivateSendReservation = { + schema: 1, + family: 'private_send_reservation', + owner: snapshot.record.owner, + id: snapshot.record.id, + revision: 0, + peer: snapshot.record.peer, + rumorHash: snapshot.record.rumorHash, + createdAt: snapshot.record.createdAt + }; + const current = () => { + const observed = rumorPlanSnapshot(plan), + source = recoveredSelfEnvelopeSnapshot(recovered); + return ( + ownership.current() && + !!source && + observed?.wire === source.rumorWire && + source.record.id === record.id && + source.record.owner === record.owner && + source.record.peer === record.peer && + source.record.rumorHash === record.rumorHash && + source.record.createdAt === record.createdAt + ); + }; + const identity = Object.freeze({}) as ReservedSendIdentity; + identities.set(identity, { record, plan, current }); + return current() ? identity : undefined; +} // Internal memory-only input to future encryption. A detached wire/snapshot is // neither reserved identity nor effect permission and cannot retarget a send. export function reservedSendRumorWire( diff --git a/web/src/lib/nostr/self-recovery-reader.ts b/web/src/lib/nostr/self-recovery-reader.ts @@ -0,0 +1,345 @@ +import { ExtensionSigner } from 'applesauce-signers'; +import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts'; +import { canonicalLocalId } from '../private-handles.ts'; +import { exactLocalFields } from '../contracts/local-records.ts'; +import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts'; +import { + identityMessagingOwnership, + subscribeIdentityInvalidation, + disconnectIdentity, + type IdentitySession +} from '../runtime/identity-session.ts'; +import { + loadPrivateRecord, + type PrivateStorageRepository, + type PrivateStorageFailure +} from '../persistence/private-storage.ts'; +import { + privateRecordSnapshot, + privateRecordWire, + type PrivateSendOperation +} from '../persistence/private-records.ts'; +import { + verifyEnvelope, + verifiedEnvelopeSnapshot +} from './verified-envelope.ts'; +import { verifyOutboundLayerData } from './outbound-envelope-layers.ts'; +import { sealCiphertextV2 } from './seal-template.ts'; +import { + browserExtensionScheduler, + runExtensionAction, + callExtension, + stopExtensionAction, + markExtensionWaitExpired, + type ExtensionAction +} from './extension-scheduler.ts'; +declare const readerBrand: unique symbol; +declare const recoveredBrand: unique symbol; +export type SelfRecoveryReader = Readonly<{ [readerBrand]: true }>; +export type RecoveredSelfEnvelope = Readonly<{ [recoveredBrand]: true }>; +type Snapshot = Readonly<{ + record: PrivateSendOperation; + storedWire: string; + rumorWire: string; + sealWire: string; +}>; +export type SelfRecoveryReadResult = + | Readonly<{ status: 'recovered'; envelope: RecoveredSelfEnvelope }> + | Readonly<{ + status: + | PrivateStorageFailure + | 'invalid' + | 'stopped' + | 'busy' + | 'refused' + | 'mismatch' + | 'lost_evidence'; + }>; +type Reader = { + run(): Promise<SelfRecoveryReadResult>; + stop(expired: boolean): void; +}; +const readers = new WeakMap<SelfRecoveryReader, Reader>(), + recovered = new WeakMap< + RecoveredSelfEnvelope, + { snapshot: Snapshot; current(): boolean } + >(); +// Actual owner-scoped storage and guarded SDK decryption are the only issuer. +// Detached JSON, metadata, SDK cache symbols and snapshots cannot mint this +// memory-only authenticated recovery proof or authorize a private relay effect. +export function captureSelfRecoveryReader( + repository: PrivateStorageRepository, + session: IdentitySession, + localId: unknown, + review: unknown +): SelfRecoveryReader | undefined { + if (typeof window === 'undefined' || review !== 'reviewed_self_decryption') + return undefined; + const inputId = canonicalLocalId(localId), + inputOwnership = identityMessagingOwnership(session); + if (!inputId || !inputOwnership?.current()) return undefined; + const id = inputId, + ownership = inputOwnership; + let stopped = false, + started = false, + active: ExtensionAction | undefined, + proof: RecoveredSelfEnvelope | undefined, + unsubscribe = () => {}; + const current = () => !stopped && ownership.current(); + function stop(expired: boolean) { + stopped = true; + if (active) { + if (expired) markExtensionWaitExpired(active); + else stopExtensionAction(active); + } + if (proof) recovered.delete(proof); + proof = undefined; + unsubscribe(); + unsubscribe = () => {}; + } + function port() { + try { + if (!current()) return undefined; + const cipher = new ExtensionSigner().nip44; + if (!current() || !cipher) return undefined; + const method = cipher.decrypt; + if (!current() || typeof method !== 'function') return undefined; + const decrypt = method.bind(cipher); + return current() ? { decrypt } : undefined; + } catch { + return undefined; + } + } + async function fresh(action: ExtensionAction) { + if (!current()) return false; + const result = await callExtension(action, 'key', () => + new ExtensionSigner().getPublicKey() + ); + if (!current()) return false; + if ( + result.status !== 'settled' || + !result.current || + result.value !== ownership.owner || + !port() + ) { + disconnectIdentity(session); + return false; + } + return current(); + } + async function run(): Promise<SelfRecoveryReadResult> { + if (started || !current()) return { status: 'stopped' }; + started = true; + if (!navigator.locks?.request) return { status: 'unavailable' }; + try { + return await navigator.locks.request( + 'harvestcircle:owner:' + ownership.owner, + { mode: 'exclusive', ifAvailable: true }, + async (lock): Promise<SelfRecoveryReadResult> => { + if (!lock) return { status: 'busy' }; + if (!current()) return { status: 'stopped' }; + // Complete the readonly transaction before any extension await. + const loaded = await loadPrivateRecord( + 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, + ownership.owner, + id + ), + storedWire = privateRecordWire(loaded.value, ownership.owner, id); + if (!record || !storedWire || record.family === 'received_envelope') + return { status: 'invalid_scope' }; + if (record.family !== 'private_send_operation') + return { status: 'lost_evidence' }; + const verified = verifyEnvelope(record.self.wire), + outer = verified.ok && verifiedEnvelopeSnapshot(verified.value); + if ( + !outer || + outer.id !== record.self.eventId || + outer.kind !== 1059 || + JSON.stringify(outer.tags) !== + JSON.stringify([['p', record.owner]]) || + !exactLocalFields(outer, [ + 'id', + 'pubkey', + 'created_at', + 'kind', + 'tags', + 'content', + 'sig' + ]) || + !sealCiphertextV2(outer.content) + ) + return { status: 'mismatch' }; + const scheduler = browserExtensionScheduler(); + if (!scheduler) return { status: 'unavailable' }; + const result = await runExtensionAction( + scheduler, + { + owner: ownership.owner, + session: ownership.session, + operation: Symbol() + }, + current, + async (action): Promise<SelfRecoveryReadResult> => { + active = action; + if (!(await fresh(action))) return { status: 'stopped' }; + const outerPort = port(); + if (!outerPort || !current()) return { status: 'stopped' }; + const opened = await callExtension(action, 'decrypt', () => + outerPort.decrypt(outer.pubkey, outer.content) + ); + if (!current()) return { status: 'stopped' }; + if (opened.status !== 'settled' || !opened.current) + return { + status: opened.status === 'denied' ? 'refused' : 'stopped' + }; + if ( + typeof opened.value !== 'string' || + !boundedUtf8(opened.value, PRIVATE_TRANSPORT_BUDGETS.sealBytes) + ) + return { status: 'mismatch' }; + const sealWire = opened.value, + verifiedSeal = verifyEnvelope(sealWire), + seal = + verifiedSeal.ok && + verifiedEnvelopeSnapshot(verifiedSeal.value); + if ( + !seal || + seal.pubkey !== record.owner || + seal.kind !== 13 || + seal.tags.length !== 0 || + !exactLocalFields(seal, [ + 'id', + 'pubkey', + 'created_at', + 'kind', + 'tags', + 'content', + 'sig' + ]) || + JSON.stringify(JSON.parse(sealWire)) !== sealWire || + !sealCiphertextV2(seal.content) + ) + return { status: 'mismatch' }; + if (!(await fresh(action))) return { status: 'stopped' }; + const innerPort = port(); + if (!innerPort || !current()) return { status: 'stopped' }; + const decrypted = await callExtension(action, 'decrypt', () => + innerPort.decrypt(seal.pubkey, seal.content) + ); + if (!current()) return { status: 'stopped' }; + if (decrypted.status !== 'settled' || !decrypted.current) + return { + status: decrypted.status === 'denied' ? 'refused' : 'stopped' + }; + if ( + typeof decrypted.value !== 'string' || + !boundedUtf8( + decrypted.value, + PRIVATE_TRANSPORT_BUDGETS.rumorBytes + ) + ) + return { status: 'mismatch' }; + const rumorWire = decrypted.value; + if ( + !verifyOutboundLayerData( + rumorWire, + rumorWire, + sealWire, + record.self.wire, + record.owner, + record.peer, + 'self' + ) + ) + return { status: 'mismatch' }; + const rumor = JSON.parse(rumorWire) as { + id: string; + created_at: number; + }; + if ( + JSON.stringify(JSON.parse(rumorWire)) !== rumorWire || + rumor.id !== record.rumorHash || + rumor.created_at !== record.createdAt + ) + return { status: 'mismatch' }; + if (!(await fresh(action))) return { status: 'stopped' }; + const readback = await loadPrivateRecord( + repository, + 'private_sends', + id + ); + if (!current()) return { status: 'stopped' }; + if (!readback.ok) + return { + status: + readback.reason === 'invalid_record' + ? 'lost_evidence' + : readback.reason + }; + if ( + privateRecordWire(readback.value, record.owner, id) !== + storedWire + ) + return { status: 'conflict' }; + if (!(await fresh(action))) return { status: 'stopped' }; + const token = Object.freeze({}) as RecoveredSelfEnvelope; + recovered.set(token, { + snapshot: { record, storedWire, rumorWire, sealWire }, + current + }); + proof = token; + return { status: 'recovered', envelope: token }; + } + ); + if (!current()) return { status: 'stopped' }; + if (result.status === 'busy') return { status: 'busy' }; + return result.status === 'completed' && + 'value' in result && + result.value + ? result.value + : { status: result.status === 'denied' ? 'refused' : 'stopped' }; + } + ); + } catch { + return { status: current() ? 'refused' : 'stopped' }; + } finally { + active = undefined; + } + } + const token = Object.freeze({}) as SelfRecoveryReader; + readers.set(token, { run, stop }); + unsubscribe = subscribeIdentityInvalidation(session, () => stop(false)); + return current() ? token : undefined; +} +export function readSelfRecoveryEnvelope( + reader: SelfRecoveryReader +): Promise<SelfRecoveryReadResult> { + return readers.get(reader)?.run() ?? Promise.resolve({ status: 'invalid' }); +} +export function stopSelfRecoveryReader(reader: SelfRecoveryReader): void { + readers.get(reader)?.stop(false); +} +export function expireSelfRecoveryReaderWait(reader: SelfRecoveryReader): void { + readers.get(reader)?.stop(true); +} +export function recoveredSelfEnvelopeSnapshot( + token: RecoveredSelfEnvelope +): Snapshot | undefined { + const saved = recovered.get(token); + return saved?.current() + ? (JSON.parse(JSON.stringify(saved.snapshot)) as Snapshot) + : undefined; +} diff --git a/web/src/lib/nostr/verify-outbound-envelope.ts b/web/src/lib/nostr/verify-outbound-envelope.ts @@ -10,6 +10,10 @@ import { } from './giftwrap-builder.ts'; import { privateSealSnapshot, privateSealReservation } from './seal-builder.ts'; import { verifyOutboundLayerData } from './outbound-envelope-layers.ts'; +import { + recoveredSelfEnvelopeSnapshot, + type RecoveredSelfEnvelope +} from './self-recovery-reader.ts'; declare const outboundBrand: unique symbol; export type VerifiedOutboundEnvelope = Readonly<{ [outboundBrand]: true }>; type Saved = Readonly<{ @@ -17,6 +21,10 @@ type Saved = Readonly<{ wrap: PrivateGiftwrap; }>; const proofs = new WeakMap<VerifiedOutboundEnvelope, Saved>(); +const recoveredProofs = new WeakMap< + VerifiedOutboundEnvelope, + { reserved: ReservedSendIdentity; source: RecoveredSelfEnvelope } +>(); function inspect(reserved: ReservedSendIdentity, wrap: PrivateGiftwrap) { const record = reservedSendSnapshot(reserved), rumor = reservedSendRumorWire(reserved), @@ -72,5 +80,67 @@ export function verifyOutboundEnvelope( } export function verifiedOutboundSnapshot(token: VerifiedOutboundEnvelope) { const saved = proofs.get(token); - return saved ? inspect(saved.reserved, saved.wrap) : undefined; + if (saved) return inspect(saved.reserved, saved.wrap); + const recovery = recoveredProofs.get(token); + return recovery && inspectRecovered(recovery.reserved, recovery.source); +} +function inspectRecovered( + reserved: ReservedSendIdentity, + source: RecoveredSelfEnvelope +) { + const original = recoveredSelfEnvelopeSnapshot(source), + record = reservedSendSnapshot(reserved), + wire = reservedSendRumorWire(reserved); + if ( + !original || + !record || + wire !== original.rumorWire || + record.owner !== original.record.owner || + record.id !== original.record.id || + record.peer !== original.record.peer || + record.rumorHash !== original.record.rumorHash || + record.createdAt !== original.record.createdAt || + !verifyOutboundLayerData( + wire, + wire, + original.sealWire, + original.record.self.wire, + record.owner, + record.peer, + 'self' + ) + ) + return undefined; + return { + owner: record.owner, + peer: record.peer, + destination: record.owner, + role: 'self' as const, + command: record.id, + rumorHash: record.rumorHash, + wire: original.record.self.wire + }; +} +export function verifyRecoveredSelfEnvelope( + reserved: ReservedSendIdentity, + source: RecoveredSelfEnvelope, + review: unknown +): VerifiedOutboundEnvelope | undefined { + if ( + review !== 'reviewed_recovered_self' || + !inspectRecovered(reserved, source) + ) + return undefined; + const token = Object.freeze({}) as VerifiedOutboundEnvelope; + recoveredProofs.set(token, { reserved, source }); + return token; +} +// Extra full-wire custody fence for actual recovery, absent for new factories. +export function verifiedOutboundRecoverySource( + token: VerifiedOutboundEnvelope +): string | undefined { + const recovery = recoveredProofs.get(token); + return recovery && inspectRecovered(recovery.reserved, recovery.source) + ? recoveredSelfEnvelopeSnapshot(recovery.source)?.storedWire + : undefined; } diff --git a/web/src/lib/persistence/private-sends.ts b/web/src/lib/persistence/private-sends.ts @@ -8,6 +8,7 @@ import { } from '../messaging/send-identity.ts'; import { verifiedOutboundSnapshot, + verifiedOutboundRecoverySource, type VerifiedOutboundEnvelope } from '../nostr/verify-outbound-envelope.ts'; import { @@ -129,7 +130,8 @@ function input( record, current, ownerCurrent: () => ownership.current(), - self: { eventId: event.id, wire: observed.wire } + self: { eventId: event.id, wire: observed.wire }, + recoveryWire: verifiedOutboundRecoverySource(proof) } : undefined; } @@ -159,6 +161,15 @@ export async function commitSelfRecovery( ); if (!base || base.family === 'received_envelope') return { status: 'invalid_record' }; + if ( + captured.recoveryWire !== undefined && + privateRecordWire( + loaded.value, + captured.record.owner, + captured.record.id + ) !== captured.recoveryWire + ) + return { status: 'conflict' }; let expected: PrivateRecordHandle, status: 'saved' | 'existing' | 'reconciled'; if (base.family === 'private_send_operation') { diff --git a/web/tests/e2e/harness/resume-preparation.ts b/web/tests/e2e/harness/resume-preparation.ts @@ -0,0 +1,404 @@ +import { + finalizeEvent, + getPublicKey, + type UnsignedEvent +} from 'applesauce-core/helpers'; +import { nip44 } from 'applesauce-core/helpers/encryption'; +import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts'; +import { + createIdentitySession, + connectIdentity, + probeIdentityMessaging, + disconnectIdentity +} from '../../../src/lib/runtime/identity-session.ts'; +import { + openBrowserDatabase, + closeBrowserDatabase, + browserDatabaseTransaction +} from '../../../src/lib/persistence/database.ts'; +import { + createPrivateStorageRepository, + loadPrivateRecord +} from '../../../src/lib/persistence/private-storage.ts'; +import { + privateRecordSnapshot, + privateRecordWire, + decodePrivateRecord +} from '../../../src/lib/persistence/private-records.ts'; +import { createPrivateSendReservationRepository } from '../../../src/lib/persistence/private-send-reservations.ts'; +import { captureEnquiryContext } from '../../../src/lib/messaging/enquiry-context.ts'; +import { + captureEnquiryRumor, + stopRumorPlan, + rumorPlanSnapshot +} from '../../../src/lib/messaging/rumor-plan.ts'; +import { + reserveSendIdentity, + reservedSendSnapshot +} from '../../../src/lib/messaging/send-identity.ts'; +import { + captureSelfRecoveryPreparation, + prepareSelfRecovery, + stopSelfRecoveryPreparation +} from '../../../src/lib/messaging/prepare-send.ts'; +import { + browserExtensionScheduler, + extensionSchedulerSnapshot +} from '../../../src/lib/nostr/extension-scheduler.ts'; +import { validateRelayPolicy } from '../../../src/lib/config/relays.ts'; +import { + createPublicScheduler, + createPublicRun, + openInboxRequest, + closePublicScheduler +} from '../../../src/lib/nostr/request-scope.ts'; +import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts'; +import { createInboxRoutePlan } from '../../../src/lib/messaging/inbox-routing.ts'; +import { + captureResumePreparation, + resumeEncryptedPreparation, + resumePreparationSnapshot, + resumeRecoveredRumor, + stopResumePreparation +} from '../../../src/lib/messaging/resume-preparation.ts'; +export { + captureResumePreparation, + resumeEncryptedPreparation, + resumePreparationSnapshot, + resumeRecoveredRumor, + stopResumePreparation, + rumorPlanSnapshot +}; +// Public disposable fixture keys, never installed operator credentials. Stable +// only so an actual page reload can unlock the same actual stored ciphertext. +const command = '12345678-1234-4234-8234-123456789abc', + marker = 'HCP083_PRIVATE_RECOVERY_MEMORY_ONLY_SENTINEL'; +type Mode = + | 'normal' + | 'changed_key' + | 'hold_decrypt' + | 'declined_decrypt' + | 'wrong_plaintext'; +export async function makeFixture(initialise = true) { + const secret = new Uint8Array(32).fill(83), + peerSecret = new Uint8Array(32).fill(84), + owner = getPublicKey(secret), + peer = getPublicKey(peerSecret); + let mode: Mode = 'normal', + keys = 0, + encrypts = 0, + decrypts = 0, + signs = 0, + release: (() => void) | undefined; + function encrypt(target: string, text: string) { + const conversation = nip44.v2.utils.getConversationKey(secret, target); + try { + return nip44.v2.encrypt(text, conversation); + } finally { + conversation.fill(0); + } + } + function decrypt(target: string, wire: string) { + const conversation = nip44.v2.utils.getConversationKey(secret, target); + try { + return nip44.v2.decrypt(wire, conversation); + } finally { + conversation.fill(0); + } + } + Object.defineProperty(window, 'nostr', { + configurable: true, + value: { + getPublicKey: () => { + keys++; + return Promise.resolve(mode === 'changed_key' ? peer : owner); + }, + signEvent: (template: UnsignedEvent) => { + signs++; + return Promise.resolve(finalizeEvent(template, secret)); + }, + nip44: { + encrypt: (target: string, text: string) => { + encrypts++; + return Promise.resolve(encrypt(target, text)); + }, + decrypt: (target: string, wire: string) => { + decrypts++; + if (mode === 'declined_decrypt') + return Promise.reject(Error('controlled decryption refusal')); + const work = () => + mode === 'wrong_plaintext' ? '{}' : decrypt(target, wire); + return mode === 'hold_decrypt' + ? new Promise<string>((resolve) => { + release = () => resolve(work()); + }) + : Promise.resolve(work()); + } + } + } + }); + const identity = createIdentitySession(); + await connectIdentity(identity); + await probeIdentityMessaging(identity, 'reviewed_self_copy'); + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') throw Error('fixture storage unavailable'); + const database = opened.owner, + repository = createPrivateStorageRepository(database, owner); + if (!repository) throw Error('fixture namespace unavailable'); + if (initialise) { + const listing = finalizeEvent( + { + kind: 30402, + created_at: 1700000060, + content: 'Public carrots', + tags: [ + ['d', 'carrots'], + ['title', 'Carrots'], + ['summary', 'Fresh carrots'], + ['published_at', '1700000000'], + ['location', 'Victoria'], + ['price', '3.5', 'CAD'], + ['radroots:price_unit', 'lb'], + ['status', 'active'] + ] + }, + peerSecret + ); + const verified = verifyEnvelope(JSON.stringify(listing)), + context = verified.ok && captureEnquiryContext(verified.value), + observed = Date.now(); + const plan = + context && + captureEnquiryRumor( + identity, + context, + marker, + Math.floor(observed / 1000) + ); + const reservations = createPrivateSendReservationRepository( + database, + owner + ); + if (!plan || !reservations) + throw Error('fixture original intent unavailable'); + const realNow = Date.now; + Date.now = () => observed; + let reserved: Awaited<ReturnType<typeof reserveSendIdentity>>; + try { + reserved = await reserveSendIdentity( + reservations, + identity, + command, + plan, + 'reviewed_private_intent' + ); + } finally { + Date.now = realNow; + } + if (!('identity' in reserved) || !reservedSendSnapshot(reserved.identity)) + throw Error('fixture original command unavailable'); + const preparation = captureSelfRecoveryPreparation( + repository, + identity, + reserved.identity, + 'reviewed_self_recovery' + ); + if ( + !preparation || + !['saved', 'existing'].includes( + (await prepareSelfRecovery(preparation, 'reviewed_self_recovery')) + .status + ) + ) + throw Error('fixture actual self save unavailable'); + stopSelfRecoveryPreparation(preparation); + stopRumorPlan(plan); + } + const discovery = 'wss://discovery.example.org', + archive = 'wss://archive.example.org', + destination = 'wss://peer.example.org'; + const policy = validateRelayPolicy( + JSON.stringify({ + schemaVersion: 1, + public: [{ origin: discovery, read: true, write: false, nip50: false }], + inbox: [archive, destination].map((origin) => ({ + origin, + read: true, + write: true + })), + postingEnabled: false, + messagingEnabled: false, + operatorDenylist: [] + }) + ); + if (!policy) throw Error('fixture policy unavailable'); + const schedulers: ReturnType<typeof createPublicScheduler>[] = [], + tokens: ReturnType<typeof captureResumePreparation>[] = []; + let current = true; + function resolve(asPeer: boolean) { + const event = finalizeEvent( + { + kind: 10050, + created_at: 100, + tags: [['relay', asPeer ? destination : archive]], + content: '' + }, + asPeer ? peerSecret : secret + ); + const scheduler = createPublicScheduler({ + now: () => 0, + schedule: () => () => {} + }); + schedulers.push(scheduler); + const run = createPublicRun(scheduler, policy!); + return createInboxResolver( + run, + event.pubkey, + (next) => + openInboxRequest( + run, + event.pubkey, + (sink) => { + sink({ type: 'EVENT', from: discovery, id: 'fixture', event }); + sink({ type: 'EOSE', from: discovery, id: 'fixture' }); + return () => {}; + }, + next + ), + () => current + ); + } + const own = resolve(false), + other = resolve(true), + plan = createInboxRoutePlan(policy, owner, peer, own, other); + if (!plan) throw Error('fixture genuine routing unavailable'); + async function row() { + const loaded = await loadPrivateRecord( + repository!, + 'private_sends', + command + ); + if (!loaded.ok) return undefined; + const record = privateRecordSnapshot(loaded.value, owner, command), + wire = privateRecordWire(loaded.value, owner, command); + return record?.family === 'private_send_operation' && wire + ? { record, wire } + : undefined; + } + async function raw() { + const tx = browserDatabaseTransaction( + database, + ['private_sends'], + 'readonly' + ), + request = tx.objectStore('private_sends').getAll(); + return new Promise<string>((resolve, reject) => { + tx.addEventListener('complete', () => + resolve(JSON.stringify(request.result)) + ); + tx.addEventListener('abort', () => reject(Error('fixture read aborted'))); + }); + } + async function write(kind: 'erase' | 'revision' | 'corrupt') { + const original = kind === 'revision' ? await row() : undefined; + const wire = + original && + JSON.stringify({ + ...original.record, + revision: original.record.revision + 1 + }); + if ( + kind === 'revision' && + (!wire || !decodePrivateRecord(wire, owner, command).ok) + ) + throw Error('fixture successor unavailable'); + const tx = browserDatabaseTransaction( + database, + ['private_sends'], + 'readwrite' + ), + store = tx.objectStore('private_sends'); + if (kind === 'erase') store.delete([owner, command]); + else + store.put({ + owner, + id: command, + wire: kind === 'corrupt' ? '{"schema":999}' : wire + }); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('fixture write aborted')) + ); + }); + } + return { + owner, + peer, + command, + marker, + identity, + repository, + context: { plan, policy, own, other }, + row, + raw, + write, + capture() { + const token = captureResumePreparation( + repository, + identity, + command, + 'reviewed_private_resume' + ); + if (!token) throw Error('fixture resume unavailable'); + tokens.push(token); + return token; + }, + counts: () => ({ keys, encrypts, decrypts, signs }), + mode: (next: Mode) => { + mode = next; + }, + settle: () => release?.(), + pending: () => { + const scheduler = browserExtensionScheduler(), + slot = scheduler && extensionSchedulerSnapshot(scheduler); + return slot?.state === 'active' && slot.pending === 'decrypt'; + }, + disconnect: () => disconnectIdentity(identity), + decryptPeer(wire: string) { + const outer = JSON.parse(wire) as { pubkey: string; content: string }; + const conversation = nip44.v2.utils.getConversationKey( + peerSecret, + outer.pubkey + ); + let seal: { pubkey: string; content: string }; + try { + seal = JSON.parse( + nip44.v2.decrypt(outer.content, conversation) + ) as typeof seal; + } finally { + conversation.fill(0); + } + const inner = nip44.v2.utils.getConversationKey(peerSecret, seal.pubkey); + try { + return JSON.parse(nip44.v2.decrypt(seal.content, inner)) as { + id: string; + created_at: number; + content: string; + }; + } finally { + inner.fill(0); + } + }, + close() { + current = false; + for (const token of tokens) if (token) stopResumePreparation(token); + for (const scheduler of schedulers) closePublicScheduler(scheduler); + disconnectIdentity(identity); + closeBrowserDatabase(database); + secret.fill(0); + peerSecret.fill(0); + delete window.nostr; + } + }; +} diff --git a/web/tests/e2e/resume-preparation.spec.ts b/web/tests/e2e/resume-preparation.spec.ts @@ -0,0 +1,520 @@ +import { expect, test, type Page } from '@playwright/test'; +import { build } from 'vite'; +import { fileURLToPath } from 'node:url'; +import { createHash } from 'node:crypto'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Resume from './harness/resume-preparation.ts'; +declare global { + interface Window { + hcp083: typeof Resume; + hcp083Fixture: Awaited<ReturnType<typeof Resume.makeFixture>>; + hcp083Token: ReturnType<Window['hcp083Fixture']['capture']>; + hcp083Pending: Promise< + Awaited<ReturnType<typeof Resume.resumeEncryptedPreparation>> + >; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string; +test.beforeAll(async () => { + server = await createStaticHarness(); + const built = await build({ + configFile: false, + logLevel: 'silent', + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/resume-preparation.ts', import.meta.url) + ), + name: 'hcp083', + formats: ['iife'] + } + } + }); + const output = Array.isArray(built) ? built[0] : built; + if (!('output' in output)) throw Error('missing resume bundle'); + const chunks = output.output.filter((entry) => entry.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; + console.log( + JSON.stringify({ + fixture: 'HCP083_ACTUAL_RELOAD_SDK_IDB', + bundleSha256: createHash('sha256').update(bundle).digest('hex'), + moduleIds: Object.keys(chunks[0].modules), + qualification: + 'Source-only disposable provider, actual SDK/IDB/WebLocks; no installed extension/relay/client Q' + }) + ); +}); +test.afterAll(async () => server.close()); +async function load(page: Page, initialise = true) { + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + await page.evaluate(async (initialise) => { + window.hcp083Fixture = await window.hcp083.makeFixture(initialise); + }, initialise); +} +test('actual reload loses presentation capabilities and explicitly recovers the same rumor and missing peer without rebuilding self', async ({ + page +}) => { + let sockets = 0; + page.on('websocket', () => sockets++); + await load(page); + const before = await page.evaluate(async () => { + const row = await window.hcp083Fixture.row(); + if (!row) throw Error('missing self'); + return row.record; + }); + await page.reload(); + await page.addScriptTag({ content: bundle }); + await page.evaluate(async () => { + window.hcp083Fixture = await window.hcp083.makeFixture(false); + }); + const result = await page.evaluate(async () => { + const f = window.hcp083Fixture, + s = window.hcp083; + try { + const token = f.capture(), + initial = f.counts(), + raw = await f.raw(); + const recovered = await s.resumeEncryptedPreparation( + token, + undefined, + 'reviewed_private_resume' + ), + rumor = s.resumeRecoveredRumor(token), + memory = rumor && s.rumorPlanSnapshot(rumor), + afterRecovery = f.counts(); + const pair = await s.resumeEncryptedPreparation( + token, + f.context, + 'reviewed_private_resume' + ), + row = await f.row(), + peer = + row?.record.peerArtifact && + f.decryptPeer(row.record.peerArtifact.wire); + return { + recovered: recovered.status, + pair: pair.status, + memory, + record: row?.record, + peer, + noSelfCrypto: + afterRecovery.encrypts === initial.encrypts && + afterRecovery.signs === initial.signs, + privateOnly: + !raw.includes(f.marker) && !(await f.raw()).includes(f.marker) + }; + } finally { + f.close(); + } + }); + expect(result.recovered).toBe('recovered'); + expect(result.pair).toBe('prepared'); + expect(result.noSelfCrypto).toBe(true); + expect(result.privateOnly).toBe(true); + expect(result.record?.self).toEqual(before.self); + expect(result.record?.rumorHash).toBe(before.rumorHash); + expect(result.record?.createdAt).toBe(before.createdAt); + expect(result.memory?.id).toBe(before.rumorHash); + expect(result.memory?.wire).toContain( + 'HCP083_PRIVATE_RECOVERY_MEMORY_ONLY_SENTINEL' + ); + expect(result.peer?.id).toBe(before.rumorHash); + expect(result.peer?.created_at).toBe(before.createdAt); + const originalRumor = JSON.parse(result.memory!.wire) as { content: string }; + expect(result.peer?.content).toBe(originalRumor.content); + expect(result.peer?.content).toContain('Enquiry about "Carrots"'); + expect(result.peer?.content).toContain( + 'HCP083_PRIVATE_RECOVERY_MEMORY_ONLY_SENTINEL' + ); + expect(sockets).toBe(0); +}); +test('capture and unreviewed Resume spend no prompts or private effects', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp083Fixture, + s = window.hcp083; + try { + const before = f.counts(), + raw = await f.raw(), + token = f.capture(), + result = await s.resumeEncryptedPreparation(token, f.context, 'wrong'); + return { + status: result.status, + inert: JSON.stringify(before) === JSON.stringify(f.counts()), + unchanged: raw === (await f.raw()), + noRumor: !s.resumeRecoveredRumor(token) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + status: 'invalid', + inert: true, + unchanged: true, + noRumor: true + }); +}); +test('erased evidence explicitly discloses loss without a new reservation or SDK prompt', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp083Fixture, + s = window.hcp083; + try { + await f.write('erase'); + const before = f.counts(), + token = f.capture(), + r = await s.resumeEncryptedPreparation( + token, + f.context, + 'reviewed_private_resume' + ); + return { + status: r.status, + copy: s.resumePreparationSnapshot(token)?.copy, + inert: JSON.stringify(before) === JSON.stringify(f.counts()), + raw: await f.raw(), + noRumor: !s.resumeRecoveredRumor(token) + }; + } finally { + f.close(); + } + }); + expect(result.status).toBe('lost_evidence'); + expect(result.copy).toContain('lost'); + expect(result.inert).toBe(true); + expect(result.raw).toBe('[]'); + expect(result.noRumor).toBe(true); +}); +test('corrupt stored recovery stays intact and blocks decryption and silent reset', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp083Fixture, + s = window.hcp083; + try { + await f.write('corrupt'); + const raw = await f.raw(), + before = f.counts(), + r = await s.resumeEncryptedPreparation( + f.capture(), + f.context, + 'reviewed_private_resume' + ); + return { + status: r.status, + unchanged: raw === (await f.raw()), + inert: JSON.stringify(before) === JSON.stringify(f.counts()) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + status: 'corrupt_record', + unchanged: true, + inert: true + }); +}); +test('fresh changed extension key blocks before the first recovery decrypt', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp083Fixture, + s = window.hcp083; + try { + const raw = await f.raw(), + before = f.counts(), + token = f.capture(); + f.mode('changed_key'); + const r = await s.resumeEncryptedPreparation( + token, + f.context, + 'reviewed_private_resume' + ); + return { + status: r.status, + unchanged: raw === (await f.raw()), + noDecrypt: f.counts().decrypts === before.decrypts, + noRumor: !s.resumeRecoveredRumor(token) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + status: 'stopped', + unchanged: true, + noDecrypt: true, + noRumor: true + }); +}); +test('late decryption after Disconnect cannot restore memory or continue peer work', async ({ + page +}) => { + await load(page); + await page.evaluate(() => { + const f = window.hcp083Fixture; + f.mode('hold_decrypt'); + window.hcp083Token = f.capture(); + window.hcp083Pending = window.hcp083.resumeEncryptedPreparation( + window.hcp083Token, + f.context, + 'reviewed_private_resume' + ); + }); + await expect + .poll(() => page.evaluate(() => window.hcp083Fixture.pending())) + .toBe(true); + const result = await page.evaluate(async () => { + const f = window.hcp083Fixture, + s = window.hcp083; + try { + const raw = await f.raw(), + before = f.counts(); + f.disconnect(); + f.mode('normal'); + f.settle(); + const r = await window.hcp083Pending; + return { + status: r.status, + unchanged: raw === (await f.raw()), + noPeer: + f.counts().encrypts === before.encrypts && + f.counts().signs === before.signs, + noRumor: !s.resumeRecoveredRumor(window.hcp083Token) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + status: 'stopped', + unchanged: true, + noPeer: true, + noRumor: true + }); +}); +test('stopped pending decryption occupies the shared owner until actual settlement', async ({ + page +}) => { + await load(page); + await page.evaluate(() => { + const f = window.hcp083Fixture; + f.mode('hold_decrypt'); + window.hcp083Token = f.capture(); + window.hcp083Pending = window.hcp083.resumeEncryptedPreparation( + window.hcp083Token, + undefined, + 'reviewed_private_resume' + ); + }); + await expect + .poll(() => page.evaluate(() => window.hcp083Fixture.pending())) + .toBe(true); + const result = await page.evaluate(async () => { + const f = window.hcp083Fixture, + s = window.hcp083; + try { + s.stopResumePreparation(window.hcp083Token); + const before = f.counts(), + other = f.capture(), + r = await s.resumeEncryptedPreparation( + other, + undefined, + 'reviewed_private_resume' + ); + const noQueue = JSON.stringify(before) === JSON.stringify(f.counts()); + f.mode('normal'); + f.settle(); + return { + second: r.status, + first: (await window.hcp083Pending).status, + noQueue, + noRumor: !s.resumeRecoveredRumor(window.hcp083Token) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + second: 'busy', + first: 'stopped', + noQueue: true, + noRumor: true + }); +}); +test('decryption refusal preserves self ciphertext and never falls back to encryption or signing', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp083Fixture, + s = window.hcp083; + try { + const raw = await f.raw(), + before = f.counts(), + token = f.capture(); + f.mode('declined_decrypt'); + const r = await s.resumeEncryptedPreparation( + token, + f.context, + 'reviewed_private_resume' + ); + return { + status: r.status, + unchanged: raw === (await f.raw()), + noFallback: + f.counts().encrypts === before.encrypts && + f.counts().signs === before.signs, + noRumor: !s.resumeRecoveredRumor(token) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + status: 'refused', + unchanged: true, + noFallback: true, + noRumor: true + }); +}); +test('substituted decrypted plaintext fails authenticated rumor recovery', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp083Fixture, + s = window.hcp083; + try { + const raw = await f.raw(), + token = f.capture(); + f.mode('wrong_plaintext'); + const r = await s.resumeEncryptedPreparation( + token, + f.context, + 'reviewed_private_resume' + ); + return { + status: r.status, + unchanged: raw === (await f.raw()), + noRumor: !s.resumeRecoveredRumor(token) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + status: 'mismatch', + unchanged: true, + noRumor: true + }); +}); +test('completed pair recovery and repeated Resume retain both original artifacts without peer regeneration', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp083Fixture, + s = window.hcp083; + try { + const first = f.capture(); + await s.resumeEncryptedPreparation( + first, + f.context, + 'reviewed_private_resume' + ); + const raw = await f.raw(), + before = f.counts(), + repeat = await s.resumeEncryptedPreparation( + first, + f.context, + 'reviewed_private_resume' + ), + inert = JSON.stringify(before) === JSON.stringify(f.counts()); + s.stopResumePreparation(first); + const fresh = f.capture(), + nextBefore = f.counts(), + r = await s.resumeEncryptedPreparation( + fresh, + f.context, + 'reviewed_private_resume' + ); + return { + repeat: repeat.status, + inert, + fresh: r.status, + noPeer: + f.counts().encrypts === nextBefore.encrypts && + f.counts().signs === nextBefore.signs, + unchanged: raw === (await f.raw()) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + repeat: 'prepared', + inert: true, + fresh: 'already_prepared', + noPeer: true, + unchanged: true + }); +}); +test('unacknowledged full-wire mutation while decrypting is refused and retained', async ({ + page +}) => { + await load(page); + await page.evaluate(() => { + const f = window.hcp083Fixture; + f.mode('hold_decrypt'); + window.hcp083Token = f.capture(); + window.hcp083Pending = window.hcp083.resumeEncryptedPreparation( + window.hcp083Token, + f.context, + 'reviewed_private_resume' + ); + }); + await expect + .poll(() => page.evaluate(() => window.hcp083Fixture.pending())) + .toBe(true); + const result = await page.evaluate(async () => { + const f = window.hcp083Fixture, + s = window.hcp083; + try { + await f.write('revision'); + const raw = await f.raw(), + before = f.counts(); + f.mode('normal'); + f.settle(); + const r = await window.hcp083Pending; + return { + status: r.status, + unchanged: raw === (await f.raw()), + noPeer: + f.counts().encrypts === before.encrypts && + f.counts().signs === before.signs, + noRumor: !s.resumeRecoveredRumor(window.hcp083Token) + }; + } finally { + f.close(); + } + }); + expect(result).toEqual({ + status: 'conflict', + unchanged: true, + noPeer: true, + noRumor: true + }); +}); diff --git a/web/tests/unit/resume-preparation.test.ts b/web/tests/unit/resume-preparation.test.ts @@ -0,0 +1,50 @@ +import { describe, it, expect } from 'vitest'; +import { + captureResumePreparation, + resumeEncryptedPreparation, + resumePreparationSnapshot, + resumeRecoveredRumor, + type ResumePreparation +} from '../../src/lib/messaging/resume-preparation.ts'; +import type { PrivateStorageRepository } from '../../src/lib/persistence/private-storage.ts'; +import type { IdentitySession } from '../../src/lib/runtime/identity-session.ts'; +describe('explicit encrypted recovery cannot manufacture a new message', () => { + it('SSR and forged preparation are inert', async () => { + expect( + captureResumePreparation( + {} as PrivateStorageRepository, + {} as IdentitySession, + '12345678-1234-4234-8234-123456789abc', + 'reviewed_private_resume' + ) + ).toBeUndefined(); + expect( + await resumeEncryptedPreparation( + {} as ResumePreparation, + undefined, + 'reviewed_private_resume' + ) + ).toEqual({ status: 'invalid' }); + }); + it('detached tokens expose neither recovered text nor acknowledgement', () => { + expect(resumePreparationSnapshot({} as ResumePreparation)).toBeUndefined(); + expect(resumeRecoveredRumor({} as ResumePreparation)).toBeUndefined(); + }); + it('unreviewed input cannot coerce itself into Resume', async () => { + let calls = 0; + const review = { + toString() { + calls++; + return 'reviewed_private_resume'; + } + }; + expect( + await resumeEncryptedPreparation( + {} as ResumePreparation, + undefined, + review + ) + ).toEqual({ status: 'invalid' }); + expect(calls).toBe(0); + }); +});