app

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

commit d3fd495e7b3c59ec396a8f89eb027ed9de0f3f3c
parent c0caa4ee1a8b2dca05e0f218f8d67e541a8d7e1d
Author: triesap <tyson@radroots.org>
Date:   Wed, 14 Oct 2026 07:39:17 +0000

harvestcircle_web: Add genuine guarded inbox probe construction

- Reserve original self probes under genuine session and native storage ownership.
- Share guarded SDK seal and wrap ports while keeping ordinary tokens separate.
- Fence pending teardown, close reentry and failed artifact regeneration.
- Verify 43 units, 92 browser workflows and source/output rejection controls.

Diffstat:
Mweb/src/lib/messaging/inbox-access-controller.ts | 120++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------
Mweb/src/lib/nostr/giftwrap-builder.ts | 145++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------
Aweb/src/lib/nostr/inbox-access.ts | 357+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/nostr/seal-builder.ts | 298++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------
Mweb/tests/e2e/harness/inbox-access-controller.ts | 4++--
Mweb/tests/e2e/harness/inbox-auth.ts | 17++++++++++++-----
Aweb/tests/e2e/harness/inbox-probe.ts | 468+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/inbox-probe.spec.ts | 646+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/provenance/output.test.mjs | 3+++
Mweb/tests/provenance/source-boundaries.test.mjs | 8++++++++
Mweb/tests/unit/giftwrap-builder.test.ts | 3++-
Aweb/tests/unit/inbox-probe.test.ts | 113+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 16++++++++++++++--
Mweb/tools/source-boundaries.mjs | 2+-
14 files changed, 2054 insertions(+), 146 deletions(-)

diff --git a/web/src/lib/messaging/inbox-access-controller.ts b/web/src/lib/messaging/inbox-access-controller.ts @@ -34,6 +34,7 @@ export type InboxAccessController = Readonly<{ [accessBrand]: true }>; type Binding = Readonly<{ owner: string; preferenceId: string; + preferenceCreatedAt: number; readTargets: string[]; archiveTargets: string[]; }>; @@ -47,6 +48,8 @@ export type InboxAccessSnapshot = Readonly< } >; type Control = { + session: PrivateSession; + subscribe(listener: () => void): () => void; policy: RelayPolicy; binding: string; current(): boolean; @@ -109,6 +112,7 @@ function binding( return { owner: capture.owner, preferenceId: preference.id, + preferenceCreatedAt: preference.createdAt, readTargets, archiveTargets }; @@ -143,8 +147,10 @@ export function createInboxAccessController( if (prior && (!prior.closed() || prior.cleanupRequired())) return undefined; const token = Object.freeze({}) as InboxAccessController; const auth = new Map<string, InboxAuthAction>(); + const constructionClosures = new Map<symbol, () => void>(); let pool: PrivatePool | undefined, closed = false, + closing = false, cleaned = false, busy = false, epoch = 0, @@ -154,28 +160,44 @@ export function createInboxAccessController( !closed && JSON.stringify(binding(session, policy, own)) === wire; function close(): boolean { closed = true; - epoch++; - phase = 'stopped'; - let failed = false; - for (const [origin, action] of auth) { - try { - closeInboxAuthentication(action); - auth.delete(origin); - } catch { - failed = true; + if (closing) return false; + closing = true; + try { + epoch++; + phase = 'stopped'; + let failed = false; + // Revoke construction before any asynchronous/throwing transport cleanup. + // Only failed original closures remain registered for an honest retry. + for (const [id, listener] of constructionClosures) { + try { + listener(); + constructionClosures.delete(id); + } catch { + failed = true; + } } - } - if (pool) { - try { - closePrivatePool(pool); - } catch { - failed = true; + for (const [origin, action] of auth) { + try { + closeInboxAuthentication(action); + auth.delete(origin); + } catch { + failed = true; + } } - if (privatePoolCleanupRequired(pool)) failed = true; + if (pool) { + try { + closePrivatePool(pool); + } catch { + failed = true; + } + if (privatePoolCleanupRequired(pool)) failed = true; + } + cleaned = !failed; + if (cleaned) off(); + return cleaned; + } finally { + closing = false; } - cleaned = !failed; - if (cleaned) off(); - return cleaned; } async function authenticate( origin: unknown, @@ -247,6 +269,23 @@ export function createInboxAccessController( } } controllers.set(token, { + session, + subscribe(listener) { + const id = Symbol(); + constructionClosures.set(id, listener); + if (closed) { + try { + listener(); + constructionClosures.delete(id); + } catch (error) { + cleaned = false; + throw error; + } + } + return () => { + constructionClosures.delete(id); + }; + }, policy, binding: wire, current, @@ -312,3 +351,46 @@ export function closeInboxAccessController( ): boolean { return controllers.get(token)?.close() ?? false; } + +// Narrow source-owned construction binding. It authenticates current discovery +// metadata only; it grants neither readiness nor a socket/sign/publication port. +export function inboxAccessConstructionBinding( + token: InboxAccessController, + session: PrivateSession, + policy: RelayPolicy +): Readonly<Binding & { session: symbol; current(): boolean }> | undefined { + const state = controllers.get(token), + ownership = privateSessionOwnership(session); + if ( + !state || + state.session !== session || + state.policy !== policy || + !ownership?.current() || + !state.current() + ) + return undefined; + const captured = state.snapshot(); + if ( + captured.owner !== ownership.owner || + !state.current() || + !ownership.current() + ) + return undefined; + return { + owner: captured.owner, + preferenceId: captured.preferenceId, + preferenceCreatedAt: captured.preferenceCreatedAt, + readTargets: [...captured.readTargets], + archiveTargets: [...captured.archiveTargets], + session: ownership.session, + current: () => ownership.current() && state.current() + }; +} +export function subscribeInboxAccessControllerClose( + token: InboxAccessController, + listener: () => void +): () => void { + const state = controllers.get(token); + if (!state) throw Error('inbox_access_controller_invalid'); + return state.subscribe(listener); +} diff --git a/web/src/lib/nostr/giftwrap-builder.ts b/web/src/lib/nostr/giftwrap-builder.ts @@ -11,9 +11,13 @@ import { safeUnsignedInteger } from './envelope-bounds.ts'; import { verifyEnvelope } from './verified-envelope.ts'; import { privateSealSnapshot, + inboxProbeSealSnapshot, + type InboxProbeRecipientSeal, type PrivateRecipientSeal } from './seal-builder.ts'; +declare const probeWrapBrand: unique symbol; +export type InboxProbeGiftwrap = Readonly<{ [probeWrapBrand]: true }>; declare const giftwrapBrand: unique symbol; export type PrivateGiftwrap = Readonly<{ [giftwrapBrand]: true }>; type Saved = Readonly<{ @@ -32,45 +36,45 @@ function own(value: object, name: string): unknown { const descriptor = Object.getOwnPropertyDescriptor(value, name); return descriptor && 'value' in descriptor ? descriptor.value : undefined; } -// Only genuine current sender seals enter this lower-level construction. It -// grants no readiness, durable preparation receipt, nested admission or Send. -// All secret primitives below are public pinned Applesauce exports. Disposable -// keys are local to this synchronous factory; they never become identity keys. -export function buildPrivateGiftwrap( - seal: PrivateRecipientSeal, - review: unknown -): PrivateGiftwrap | undefined { - if (typeof window === 'undefined' || review !== 'reviewed_private_wrap') - return undefined; - const record = privateSealSnapshot(seal); - if ( - !record || - !boundedUtf8(record.wire, 16384) || - record.destination !== (record.role === 'self' ? record.owner : record.peer) - ) - return undefined; +type SavedProbeWrap = Readonly<{ + owner: string; + destination: string; + command: string; + rumorHash: string; + createdAt: number; + kind: 1059; + wire: string; + seal: InboxProbeRecipientSeal; +}>; +const probeWraps = new WeakMap<InboxProbeGiftwrap, SavedProbeWrap>(); +const originalProbeWraps = new WeakMap< + InboxProbeRecipientSeal, + InboxProbeGiftwrap | null +>(); +// Module-private stock SDK wrapper construction; only genuine ordinary/probe +// seal factories below can supply the binding. No exported callback/key port. +function constructGiftwrap( + record: Readonly<{ destination: string; wire: string }>, + current: () => boolean +): string | undefined { let secret: Uint8Array | undefined, conversation: Uint8Array | undefined; try { const milliseconds = safeUnsignedInteger(Date.now()); - if (milliseconds === undefined || !privateSealSnapshot(seal)) - return undefined; + if (milliseconds === undefined || !current()) return undefined; const random = crypto.getRandomValues(new Uint32Array(1))[0], time = Math.max(0, Math.floor(milliseconds / 1000) - (random % 3600)); - if (!privateSealSnapshot(seal)) return undefined; + if (!current()) return undefined; secret = generateSecretKey(); - if (!privateSealSnapshot(seal)) return undefined; + if (!current()) return undefined; const author = getPublicKey(secret); conversation = nip44.v2.utils.getConversationKey( secret, record.destination ); - if (!privateSealSnapshot(seal)) return undefined; + if (!current()) return undefined; const content = nip44.v2.encrypt(record.wire, conversation); - if (!privateSealSnapshot(seal)) return undefined; - if ( - nip44.v2.decrypt(content, conversation) !== record.wire || - !privateSealSnapshot(seal) - ) + if (!current()) return undefined; + if (nip44.v2.decrypt(content, conversation) !== record.wire || !current()) return undefined; const captured = JSON.stringify({ pubkey: author, @@ -117,25 +121,9 @@ export function buildPrivateGiftwrap( id, sig }); - if ( - !boundedUtf8(wire, 32768) || - !verifyEnvelope(wire).ok || - !privateSealSnapshot(seal) - ) + if (!boundedUtf8(wire, 32768) || !verifyEnvelope(wire).ok || !current()) return undefined; - const token = Object.freeze({}) as PrivateGiftwrap; - wraps.set(token, { - owner: record.owner, - peer: record.peer, - destination: record.destination, - role: record.role, - command: record.command, - rumorHash: record.rumorHash, - kind: 1059, - wire, - seal - }); - return token; + return wire; } catch { return undefined; } finally { @@ -145,6 +133,73 @@ export function buildPrivateGiftwrap( secret?.fill(0); } } +// Genuine ordinary sender seals only; probe casts grant no ordinary token. +export function buildPrivateGiftwrap( + seal: PrivateRecipientSeal, + review: unknown +): PrivateGiftwrap | undefined { + if (typeof window === 'undefined' || review !== 'reviewed_private_wrap') + return undefined; + const record = privateSealSnapshot(seal); + if ( + !record || + !boundedUtf8(record.wire, 16384) || + record.destination !== (record.role === 'self' ? record.owner : record.peer) + ) + return undefined; + const wire = constructGiftwrap(record, () => !!privateSealSnapshot(seal)); + if (!wire || !privateSealSnapshot(seal)) return undefined; + const token = Object.freeze({}) as PrivateGiftwrap; + wraps.set(token, { ...record, kind: 1059, wire, seal }); + return token; +} +// One self-only immutable crypto artifact per genuine diagnostic seal. Failed +// construction cannot silently generate a replacement artifact in this action. +export function buildInboxProbeGiftwrap( + seal: InboxProbeRecipientSeal, + review: unknown +): InboxProbeGiftwrap | undefined { + if (typeof window === 'undefined' || review !== 'reviewed_inbox_probe_wrap') + return undefined; + const record = inboxProbeSealSnapshot(seal); + if ( + !record || + record.destination !== record.owner || + !boundedUtf8(record.wire, 16384) + ) + return undefined; + if (originalProbeWraps.has(seal)) + return originalProbeWraps.get(seal) ?? undefined; + originalProbeWraps.set(seal, null); + const wire = constructGiftwrap(record, () => !!inboxProbeSealSnapshot(seal)); + if (!wire || !inboxProbeSealSnapshot(seal)) return undefined; + const token = Object.freeze({}) as InboxProbeGiftwrap; + probeWraps.set(token, { ...record, kind: 1059, wire, seal }); + originalProbeWraps.set(seal, token); + return token; +} +export function inboxProbeGiftwrapSeal( + token: InboxProbeGiftwrap +): InboxProbeRecipientSeal | undefined { + const saved = probeWraps.get(token); + return saved && inboxProbeSealSnapshot(saved.seal) ? saved.seal : undefined; +} +export function inboxProbeGiftwrapSnapshot( + token: InboxProbeGiftwrap +): Readonly<Omit<SavedProbeWrap, 'seal'>> | undefined { + const saved = probeWraps.get(token); + return saved && inboxProbeSealSnapshot(saved.seal) + ? { + owner: saved.owner, + destination: saved.destination, + command: saved.command, + rumorHash: saved.rumorHash, + createdAt: saved.createdAt, + kind: 1059, + wire: saved.wire + } + : undefined; +} // Returns only the genuine original capability, never disposable key material. export function privateGiftwrapSeal( token: PrivateGiftwrap diff --git a/web/src/lib/nostr/inbox-access.ts b/web/src/lib/nostr/inbox-access.ts @@ -0,0 +1,357 @@ +import { getEventHash, type UnsignedEvent } from 'applesauce-core/helpers'; +import { readRelayPolicy, type RelayPolicy } from '../config/relays.ts'; +import { + inboxOperatorQualificationSnapshot, + inboxOperatorQualificationWire, + type InboxOperatorQualification +} from '../config/inbox-operators.ts'; +import { + inboxAccessConstructionBinding, + subscribeInboxAccessControllerClose, + type InboxAccessController +} from '../messaging/inbox-access-controller.ts'; +import { + privateSessionOwnership, + subscribePrivateSessionClose, + withIdlePrivateLocalStorage, + type PrivateSession +} from '../runtime/private-session.ts'; +import { + privateStorageOwner, + commitPrivateRecord, + loadPrivateRecord, + type PrivateStorageRepository, + type PrivateStorageFailure +} from '../persistence/private-storage.ts'; +import { + decodePrivateRecord, + privateRecordWire, + type PrivateAccessProbe, + type PrivateRecordHandle +} from '../persistence/private-records.ts'; +import { canonicalLocalId } from '../private-handles.ts'; +import { safeUnsignedInteger } from './envelope-bounds.ts'; + +declare const probeIdentityBrand: unique symbol; +export type InboxProbeIdentity = Readonly<{ [probeIdentityBrand]: true }>; +export type InboxProbeReservationResult = + | Readonly<{ + status: 'reserved' | 'existing'; + disposition: 'stored_original'; + identity: InboxProbeIdentity; + }> + | Readonly<{ + status: PrivateStorageFailure | 'invalid' | 'busy' | 'stopped'; + disposition: 'not_created' | 'may_exist'; + }>; +type Saved = { + session: PrivateSession; + record: PrivateAccessProbe; + handle: PrivateRecordHandle; + wire(): string | undefined; + current(): boolean; + stop(): void; +}; +type Action = { + repository: PrivateStorageRepository; + session: PrivateSession; + policy: RelayPolicy; + operator: InboxOperatorQualification; + pending(): boolean; + possible(): boolean; + result(): InboxProbeReservationResult | undefined; +}; +const identities = new WeakMap<InboxProbeIdentity, Saved>(); +const actions = new WeakMap<InboxAccessController, Action>(); +// A fixed diagnostic, never a Message composer input or recognition/suppression +// authority. Only the separate current genuine construction owner sees its wire. +const diagnostic = 'Harvestcircle private inbox access check v1: '; + +export async function reserveInboxProbeIdentity( + repository: PrivateStorageRepository, + session: PrivateSession, + policy: RelayPolicy, + access: InboxAccessController, + operator: InboxOperatorQualification, + review: unknown +): Promise<InboxProbeReservationResult> { + const prior = actions.get(access); + const failure = ( + status: PrivateStorageFailure | 'invalid' | 'busy' | 'stopped' + ): InboxProbeReservationResult => ({ + status, + disposition: prior?.possible() ? 'may_exist' : 'not_created' + }); + if (review !== 'reviewed_inbox_probe_reservation') return failure('invalid'); + if (prior) { + if ( + prior.repository !== repository || + prior.session !== session || + prior.policy !== policy || + prior.operator !== operator + ) + return failure('conflict'); + if (prior.pending()) return failure('busy'); + const original = prior.result(); + if (original && 'identity' in original) { + return inboxProbeSnapshot(original.identity) + ? { ...original, status: 'existing' } + : failure('stopped'); + } + return original ?? failure('stopped'); + } + const proof = inboxAccessConstructionBinding(access, session, policy), + owner = privateSessionOwnership(session), + declaration = inboxOperatorQualificationSnapshot(operator), + operatorWire = inboxOperatorQualificationWire(operator, policy); + if ( + !proof || + !owner?.current() || + proof.owner !== owner.owner || + proof.session !== owner.session || + privateStorageOwner(repository) !== owner.owner + ) + return failure('invalid_scope'); + if ( + !declaration || + !operatorWire || + declaration.authority === 'unconfigured' || + ![...proof.readTargets, ...proof.archiveTargets].every((origin) => { + const row = declaration.relays.find((entry) => entry.origin === origin); + return ( + row && + row.auth !== 'unsupported' && + row.recipientRead === 'supported' && + row.namedArchiveAck === 'supported' && + row.exactReadback === 'supported' && + row.retention === 'operator_defined' + ); + }) + ) + return failure('unavailable'); + const binding = { + preferenceId: proof.preferenceId, + preferenceCreatedAt: proof.preferenceCreatedAt, + readTargets: [...proof.readTargets], + archiveTargets: [...proof.archiveTargets], + policyWire: JSON.stringify(readRelayPolicy(policy)), + operatorWire + }; + const frozenBinding = JSON.stringify(binding); + let pending = true, + possible = false, + result: InboxProbeReservationResult | undefined; + const action: Action = { + repository, + session, + policy, + operator, + pending: () => pending, + possible: () => possible, + result: () => result + }; + actions.set(access, action); + const refuse = ( + status: PrivateStorageFailure | 'invalid' | 'busy' | 'stopped' + ): InboxProbeReservationResult => ({ + status, + disposition: possible ? 'may_exist' : 'not_created' + }); + const actorCurrent = () => { + const actual = inboxAccessConstructionBinding(access, session, policy); + return ( + owner.current() && + proof.current() && + !!actual && + actual.session === owner.session && + actual.owner === owner.owner && + JSON.stringify({ + preferenceId: actual.preferenceId, + preferenceCreatedAt: actual.preferenceCreatedAt, + readTargets: actual.readTargets, + archiveTargets: actual.archiveTargets, + policyWire: JSON.stringify(readRelayPolicy(policy)), + operatorWire: inboxOperatorQualificationWire(operator, policy) + }) === frozenBinding + ); + }; + let captured: InboxProbeIdentity | undefined; + try { + if (typeof window === 'undefined' || !navigator.locks?.request) + return (result = refuse('unavailable')); + result = await navigator.locks.request( + 'harvestcircle:owner:' + owner.owner, + { mode: 'exclusive', ifAvailable: true }, + async (lock) => { + if (!lock) return refuse('busy'); + if (!actorCurrent()) return refuse('stopped'); + const idle = await withIdlePrivateLocalStorage( + session, + async (): Promise<InboxProbeReservationResult> => { + if (!actorCurrent()) return refuse('stopped'); + const milliseconds = safeUnsignedInteger(Date.now()), + id = canonicalLocalId(crypto.randomUUID()); + if (milliseconds === undefined || !id || !actorCurrent()) + return refuse('invalid_record'); + const createdAt = Math.floor(milliseconds / 1000), + nonceBytes = crypto.getRandomValues(new Uint8Array(32)); + let wire: string | undefined; + try { + const nonce = Array.from(nonceBytes, (byte) => + byte.toString(16).padStart(2, '0') + ).join(''); + const rumor: UnsignedEvent = { + pubkey: owner.owner, + created_at: createdAt, + kind: 14, + tags: [['p', owner.owner]], + content: diagnostic + nonce + }; + wire = JSON.stringify({ id: getEventHash(rumor), ...rumor }); + } finally { + nonceBytes.fill(0); + } + if (!wire || !actorCurrent()) return refuse('stopped'); + const rumorHash = (JSON.parse(wire) as { id: string }).id; + const record: PrivateAccessProbe = { + schema: 1, + family: 'private_access_probe', + owner: owner.owner, + id, + revision: 0, + rumorHash, + createdAt, + binding, + self: null, + receipts: [] + }; + const handle = decodePrivateRecord( + JSON.stringify(record), + owner.owner, + id + ); + if (!handle.ok || !actorCurrent()) return refuse('invalid_record'); + const originalWire = privateRecordWire( + handle.value, + owner.owner, + id + ); + if (!originalWire) return refuse('invalid_record'); + const token = Object.freeze({}) as InboxProbeIdentity; + let stopped = false, + offSession = () => {}, + offAccess = () => {}; + const saved: Saved = { + session, + record, + handle: handle.value, + wire: () => wire, + current() { + if (stopped || !actorCurrent()) { + saved.stop(); + return false; + } + return wire !== undefined; + }, + stop() { + stopped = true; + wire = undefined; + offSession(); + offAccess(); + } + }; + captured = token; + identities.set(token, saved); + offSession = subscribePrivateSessionClose(session, () => + saved.stop() + ); + offAccess = subscribeInboxAccessControllerClose(access, () => + saved.stop() + ); + if (!saved.current()) { + saved.stop(); + return refuse('stopped'); + } + possible = true; + const committed = await commitPrivateRecord( + repository, + handle.value, + null + ); + if (!committed.ok) { + possible = ![ + 'capacity', + 'invalid_record', + 'invalid_scope', + 'aborted' + ].includes(committed.reason); + saved.stop(); + return refuse(committed.reason); + } + if (!saved.current()) return refuse('stopped'); + const readback = await loadPrivateRecord( + repository, + 'private_sends', + id + ); + if ( + !readback.ok || + privateRecordWire(readback.value, owner.owner, id) !== + originalWire || + !saved.current() + ) { + saved.stop(); + return refuse(readback.ok ? 'conflict' : readback.reason); + } + return { + status: + committed.value.state === 'committed' ? 'reserved' : 'existing', + disposition: 'stored_original', + identity: token + }; + } + ); + return idle.ok + ? idle.value + : refuse(actorCurrent() ? 'busy' : 'stopped'); + } + ); + return result; + } catch { + if (captured) identities.get(captured)?.stop(); + return (result = refuse('unavailable')); + } finally { + pending = false; + if (!result || !('identity' in result)) { + if (captured) identities.get(captured)?.stop(); + } + } +} +export function inboxProbeSnapshot( + identity: InboxProbeIdentity +): PrivateAccessProbe | undefined { + const saved = identities.get(identity); + return saved?.current() + ? (JSON.parse(JSON.stringify(saved.record)) as PrivateAccessProbe) + : undefined; +} +// Genuine original session association; neither detached wire nor a same-owner +// replacement session can supply the original memory-only crypto input. +export function inboxProbeRumorWire( + identity: InboxProbeIdentity, + session: PrivateSession +): string | undefined { + const saved = identities.get(identity); + return saved?.session === session && saved.current() + ? saved.wire() + : undefined; +} +export function inboxProbeReservationHandle( + identity: InboxProbeIdentity +): PrivateRecordHandle | undefined { + const saved = identities.get(identity); + return saved?.current() ? saved.handle : undefined; +} +export function stopInboxProbeIdentity(identity: InboxProbeIdentity): void { + identities.get(identity)?.stop(); +} diff --git a/web/src/lib/nostr/seal-builder.ts b/web/src/lib/nostr/seal-builder.ts @@ -1,3 +1,14 @@ +import { + inboxProbeSnapshot, + inboxProbeRumorWire, + stopInboxProbeIdentity, + type InboxProbeIdentity +} from './inbox-access.ts'; +import { + privateSessionOwnership, + invalidatePrivateSessionGeneration, + type PrivateSession +} from '../runtime/private-session.ts'; import { ExtensionSigner } from 'applesauce-signers'; import type { UnsignedEvent } from 'applesauce-core/helpers'; import { @@ -24,18 +35,24 @@ import { captureSealTemplate, bindSealResponse } from './seal-template.ts'; +declare const probeOperationBrand: unique symbol; +declare const probeSealBrand: unique symbol; declare const operationBrand: unique symbol; declare const sealBrand: unique symbol; export type PrivateSealOperation = Readonly<{ [operationBrand]: true }>; export type PrivateRecipientSeal = Readonly<{ [sealBrand]: true }>; -export type PrivateSealResult = - | Readonly<{ status: 'sealed'; seal: PrivateRecipientSeal }> +export type InboxProbeSealOperation = Readonly<{ [probeOperationBrand]: true }>; +export type InboxProbeRecipientSeal = Readonly<{ [probeSealBrand]: true }>; +export type PrivateSealResult = SealResult<PrivateRecipientSeal>; +export type InboxProbeSealResult = SealResult<InboxProbeRecipientSeal>; +type SealResult<T> = + | Readonly<{ status: 'sealed'; seal: T }> | Readonly<{ status: 'invalid' | 'busy' | 'unavailable' | 'refused' | 'stopped' | 'mismatch'; }>; -type State = { - run(): Promise<PrivateSealResult>; +type State<T> = { + run(): Promise<SealResult<T>>; stop(expired: boolean): void; }; type SavedSeal = Readonly<{ @@ -49,50 +66,50 @@ type SavedSeal = Readonly<{ reserved: ReservedSendIdentity; current(): boolean; }>; -const operations = new WeakMap<PrivateSealOperation, State>(); +const operations = new WeakMap< + PrivateSealOperation, + State<PrivateRecipientSeal> +>(); const seals = new WeakMap<PrivateRecipientSeal, SavedSeal>(); -// Explicit lower-level crypto preparation, not inbox readiness, durable CAS, -// saved-encrypted evidence, a Send controller or a public/private publisher. -export function capturePrivateSealOperation( - session: IdentitySession, - reserved: ReservedSendIdentity, - role: unknown, - review: unknown -): PrivateSealOperation | undefined { - if ( - review !== 'reviewed_private_seal' || - (role !== 'peer' && role !== 'self') - ) - return undefined; - const inputRecord = reservedSendSnapshot(reserved), - inputOwnership = identityMessagingOwnership(session); - if ( - !inputRecord || - !inputOwnership || - inputRecord.owner !== inputOwnership.owner || - !inputOwnership.current() - ) - return undefined; - const record = inputRecord, - ownership = inputOwnership, - capturedRole = role; - const target = capturedRole === 'self' ? record.owner : record.peer; +type SavedProbeSeal = Readonly<{ + owner: string; + destination: string; + command: string; + rumorHash: string; + createdAt: number; + wire: string; + identity: InboxProbeIdentity; + current(): boolean; +}>; +const probeOperations = new WeakMap< + InboxProbeSealOperation, + State<InboxProbeRecipientSeal> +>(); +const probeSeals = new WeakMap<InboxProbeRecipientSeal, SavedProbeSeal>(); +const originalProbeOperations = new WeakMap< + InboxProbeIdentity, + InboxProbeSealOperation +>(); +type SealSource<T> = Readonly<{ + owner: string; + destination: string; + session: symbol; + current(): boolean; + rumorWire(): string | undefined; + invalidate(): void; + retire?(): void; + accept(wire: string, current: () => boolean): T; +}>; +// Module-private construction port. Only the two genuine capability factories +// below can supply it; callers cannot pass a signer, plaintext or current flag. +function createSealOperation<T>(source: SealSource<T>): State<T> { let stopped = false, started = false, active: ExtensionAction | undefined; - const current = () => { - const observed = reservedSendSnapshot(reserved); - return ( - !stopped && - ownership.current() && - observed?.owner === record.owner && - observed.id === record.id && - observed.peer === record.peer && - observed.rumorHash === record.rumorHash - ); - }; + const current = () => !stopped && source.current(); function stop(expired: boolean) { stopped = true; + source.retire?.(); if (active) { if (expired) markExtensionWaitExpired(active); else stopExtensionAction(active); @@ -132,34 +149,34 @@ export function capturePrivateSealOperation( if ( result.status !== 'settled' || !result.current || - result.value !== record.owner + result.value !== source.owner ) { - disconnectIdentity(session); + source.invalidate(); return false; } const cipher = cipherPort(); if (!current()) return false; if (!cipher) { - disconnectIdentity(session); + source.invalidate(); return false; } return current(); } - async function work(action: ExtensionAction): Promise<PrivateSealResult> { + async function work(action: ExtensionAction): Promise<SealResult<T>> { active = action; const initial = cipherPort(); if (!current()) return { status: 'stopped' }; if (!initial) { - disconnectIdentity(session); + source.invalidate(); return { status: 'unavailable' }; } if (!(await fresh(action))) return { status: 'stopped' }; - const wire = reservedSendRumorWire(reserved), + const wire = source.rumorWire(), cipher = cipherPort(); - if (!cipher && current()) disconnectIdentity(session); + if (!cipher && current()) source.invalidate(); if (!wire || !cipher || !current()) return { status: 'stopped' }; const encrypted = await callExtension(action, 'encrypt', () => - cipher.encrypt(target, wire) + cipher.encrypt(source.destination, wire) ); if (!current()) return { status: 'stopped' }; if (encrypted.status !== 'settled' || !encrypted.current) @@ -169,12 +186,12 @@ export function capturePrivateSealOperation( const decryptPort = cipherPort(); if (!decryptPort || !current()) return { status: 'stopped' }; const decrypted = await callExtension(action, 'decrypt', () => - decryptPort.decrypt(target, encrypted.value) + decryptPort.decrypt(source.destination, encrypted.value) ); if (!current()) return { status: 'stopped' }; if (decrypted.status !== 'settled' || !decrypted.current) return { status: decrypted.status === 'denied' ? 'refused' : 'stopped' }; - if (decrypted.value !== wire || reservedSendRumorWire(reserved) !== wire) + if (decrypted.value !== wire || source.rumorWire() !== wire) return { status: 'mismatch' }; if (!(await fresh(action))) return { status: 'stopped' }; const milliseconds = safeUnsignedInteger(Date.now()); @@ -184,7 +201,7 @@ export function capturePrivateSealOperation( const random = crypto.getRandomValues(new Uint32Array(1))[0], now = Math.floor(milliseconds / 1000), time = Math.max(0, now - (random % 3600)); - const captured = captureSealTemplate(record.owner, encrypted.value, time); + const captured = captureSealTemplate(source.owner, encrypted.value, time); if (!captured || !current()) return { status: 'mismatch' }; const response = await callExtension(action, 'sign', () => new ExtensionSigner().signEvent(JSON.parse(captured) as UnsignedEvent) @@ -196,30 +213,19 @@ export function capturePrivateSealOperation( if (!signed) return { status: 'mismatch' }; if (!(await fresh(action))) return { status: 'stopped' }; if (!current()) return { status: 'stopped' }; - const seal = Object.freeze({}) as PrivateRecipientSeal; - seals.set(seal, { - owner: record.owner, - peer: record.peer, - destination: target, - role: capturedRole, - command: record.id, - rumorHash: record.rumorHash, - wire: signed, - reserved, - current - }); + const seal = source.accept(signed, current); return { status: 'sealed', seal }; } - async function run(): Promise<PrivateSealResult> { + async function run(): Promise<SealResult<T>> { if (started || !current()) return { status: 'stopped' }; started = true; if (typeof window === 'undefined' || !navigator.locks?.request) return { status: 'unavailable' }; try { return await navigator.locks.request( - 'harvestcircle:owner:' + record.owner, + 'harvestcircle:owner:' + source.owner, { mode: 'exclusive', ifAvailable: true }, - async (lock): Promise<PrivateSealResult> => { + async (lock): Promise<SealResult<T>> => { if (!lock) return { status: 'busy' }; if (!current()) return { status: 'stopped' }; const scheduler = browserExtensionScheduler(); @@ -227,8 +233,8 @@ export function capturePrivateSealOperation( const result = await runExtensionAction( scheduler, { - owner: record.owner, - session: ownership.session, + owner: source.owner, + session: source.session, operation: Symbol() }, current, @@ -249,10 +255,160 @@ export function capturePrivateSealOperation( active = undefined; } } + return { run, stop }; +} +// Explicit ordinary preparation; probe identities never enter this factory. +export function capturePrivateSealOperation( + session: IdentitySession, + reserved: ReservedSendIdentity, + role: unknown, + review: unknown +): PrivateSealOperation | undefined { + if ( + review !== 'reviewed_private_seal' || + (role !== 'peer' && role !== 'self') + ) + return undefined; + const record = reservedSendSnapshot(reserved), + ownership = identityMessagingOwnership(session); + if (!record || !ownership?.current() || record.owner !== ownership.owner) + return undefined; + const current = () => { + const observed = reservedSendSnapshot(reserved); + return ( + ownership.current() && + observed?.owner === record.owner && + observed.id === record.id && + observed.peer === record.peer && + observed.rumorHash === record.rumorHash + ); + }; + const destination = role === 'self' ? record.owner : record.peer; + const state = createSealOperation({ + owner: record.owner, + destination, + session: ownership.session, + current, + rumorWire: () => reservedSendRumorWire(reserved), + invalidate: () => disconnectIdentity(session), + accept(wire, available) { + const seal = Object.freeze({}) as PrivateRecipientSeal; + seals.set(seal, { + owner: record.owner, + peer: record.peer, + destination, + role, + command: record.id, + rumorHash: record.rumorHash, + wire, + reserved, + current: available + }); + return seal; + } + }); const operation = Object.freeze({}) as PrivateSealOperation; - operations.set(operation, { run, stop }); + operations.set(operation, state); return operation; } + +// Distinct self-only diagnostic construction. An ordinary identity or copied +// snapshot cannot enter; one original crypto operation belongs to this issuer. +export function captureInboxProbeSealOperation( + session: PrivateSession, + identity: InboxProbeIdentity, + review: unknown +): InboxProbeSealOperation | undefined { + if (review !== 'reviewed_inbox_probe_seal') return undefined; + const record = inboxProbeSnapshot(identity), + ownership = privateSessionOwnership(session); + if ( + !record || + !ownership?.current() || + record.owner !== ownership.owner || + !inboxProbeRumorWire(identity, session) + ) + return undefined; + const prior = originalProbeOperations.get(identity); + if (prior) return prior; + const current = () => { + const observed = inboxProbeSnapshot(identity); + return ( + ownership.current() && + !!inboxProbeRumorWire(identity, session) && + observed?.owner === record.owner && + observed.id === record.id && + observed.rumorHash === record.rumorHash && + observed.createdAt === record.createdAt + ); + }; + const state = createSealOperation({ + owner: record.owner, + destination: record.owner, + session: ownership.session, + current, + rumorWire: () => inboxProbeRumorWire(identity, session), + invalidate: () => { + invalidatePrivateSessionGeneration(session); + }, + retire: () => stopInboxProbeIdentity(identity), + accept(wire, available) { + const seal = Object.freeze({}) as InboxProbeRecipientSeal; + probeSeals.set(seal, { + owner: record.owner, + destination: record.owner, + command: record.id, + rumorHash: record.rumorHash, + createdAt: record.createdAt, + wire, + identity, + current: available + }); + return seal; + } + }); + const operation = Object.freeze({}) as InboxProbeSealOperation; + probeOperations.set(operation, state); + originalProbeOperations.set(identity, operation); + return operation; +} +export function buildInboxProbeSeal( + operation: InboxProbeSealOperation +): Promise<InboxProbeSealResult> { + return ( + probeOperations.get(operation)?.run() ?? + Promise.resolve({ status: 'invalid' }) + ); +} +export function stopInboxProbeSeal(operation: InboxProbeSealOperation): void { + probeOperations.get(operation)?.stop(false); +} +export function expireInboxProbeSealWait( + operation: InboxProbeSealOperation +): void { + probeOperations.get(operation)?.stop(true); +} +export function inboxProbeSealSnapshot( + seal: InboxProbeRecipientSeal +): Readonly<Omit<SavedProbeSeal, 'current' | 'identity'>> | undefined { + const saved = probeSeals.get(seal); + return saved?.current() + ? { + owner: saved.owner, + destination: saved.destination, + command: saved.command, + rumorHash: saved.rumorHash, + createdAt: saved.createdAt, + wire: saved.wire + } + : undefined; +} +export function inboxProbeSealIdentity( + seal: InboxProbeRecipientSeal +): InboxProbeIdentity | undefined { + const saved = probeSeals.get(seal); + return saved?.current() ? saved.identity : undefined; +} export function buildPrivateSeal( operation: PrivateSealOperation ): Promise<PrivateSealResult> { diff --git a/web/tests/e2e/harness/inbox-access-controller.ts b/web/tests/e2e/harness/inbox-access-controller.ts @@ -39,7 +39,7 @@ export const origins = [ ]; // Genuine actors/SDK discovery/AUTH with controlled loopback/provided identity; // no installed extension, access probe, operator or full qualification claim. -export async function makeControllerFixture() { +export async function makeControllerFixture(actualCrypto = false) { const capturedPolicy = validateRelayPolicy( JSON.stringify({ schemaVersion: 1, @@ -59,7 +59,7 @@ export async function makeControllerFixture() { ); if (!capturedPolicy) throw Error('fixture policy'); const policy = capturedPolicy; - const fixture = await makeAuthFixture(policy); + const fixture = await makeAuthFixture(policy, actualCrypto); const context = createPublicRuntimeContext(), runtime = mountPublicRuntime(context, policy); if (!runtime) throw Error('actual public runtime'); diff --git a/web/tests/e2e/harness/inbox-auth.ts b/web/tests/e2e/harness/inbox-auth.ts @@ -45,7 +45,10 @@ export { closePublicPool } from '../../../src/lib/nostr/public-pool.ts'; export { inbox, fixturePolicy }; -export async function makeAuthFixture(selectedPolicy?: RelayPolicy) { +export async function makeAuthFixture( + selectedPolicy?: RelayPolicy, + actualCrypto = false +) { const fixture = makeFixture(10050), identity = createIdentitySession(); let mode: 'exact' | 'author' | 'relay' | 'challenge' | 'cached' | 'denied' = @@ -77,10 +80,14 @@ export async function makeAuthFixture(selectedPolicy?: RelayPolicy) { ); }, nip44: { - encrypt: (_peer: string, value: string) => - Promise.resolve('fixture:' + value), - decrypt: (_peer: string, value: string) => - Promise.resolve(value.slice(8)) + encrypt: (peer: string, value: string) => + Promise.resolve( + actualCrypto ? fixture.encrypt(peer, value) : 'fixture:' + value + ), + decrypt: (peer: string, value: string) => + Promise.resolve( + actualCrypto ? fixture.decrypt(peer, value) : value.slice(8) + ) } } }); diff --git a/web/tests/e2e/harness/inbox-probe.ts b/web/tests/e2e/harness/inbox-probe.ts @@ -0,0 +1,468 @@ +import { makeControllerFixture } from './inbox-access-controller.ts'; +import { + openBrowserDatabase, + closeBrowserDatabase, + browserDatabaseTransaction +} from '../../../src/lib/persistence/database.ts'; +import { createPrivateStorageRepository } from '../../../src/lib/persistence/private-storage.ts'; +import { + validateInboxOperatorQualification, + type InboxOperatorQualification +} from '../../../src/lib/config/inbox-operators.ts'; +import { + readRelayPolicy, + validateRelayPolicy +} from '../../../src/lib/config/relays.ts'; +import { + createIdentitySession, + connectIdentity, + probeIdentityMessaging, + disconnectIdentity +} from '../../../src/lib/runtime/identity-session.ts'; +import { + createPrivateSession, + closePrivateSession, + type PrivateSession +} from '../../../src/lib/runtime/private-session.ts'; +import { + reserveInboxProbeIdentity, + inboxProbeSnapshot, + inboxProbeRumorWire, + type InboxProbeIdentity +} from '../../../src/lib/nostr/inbox-access.ts'; +import { + captureInboxProbeSealOperation, + buildInboxProbeSeal, + type InboxProbeSealOperation, + type InboxProbeRecipientSeal +} from '../../../src/lib/nostr/seal-builder.ts'; +import { + buildInboxProbeGiftwrap, + inboxProbeGiftwrapSnapshot, + type InboxProbeGiftwrap +} from '../../../src/lib/nostr/giftwrap-builder.ts'; +import { + getEventHash, + generateSecretKey, + getPublicKey, + type UnsignedEvent +} from 'applesauce-core/helpers'; +import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts'; +import { nip44 } from 'applesauce-core/helpers/encryption'; +export * from '../../../src/lib/nostr/inbox-access.ts'; +export * from '../../../src/lib/nostr/seal-builder.ts'; +export * from '../../../src/lib/nostr/giftwrap-builder.ts'; +export * from '../../../src/lib/nostr/verify-outbound-envelope.ts'; +export * from '../../../src/lib/messaging/inbox-access-controller.ts'; +export * from '../../../src/lib/messaging/send-identity.ts'; +export * from '../../../src/lib/runtime/private-session.ts'; +export type Mode = + | 'normal' + | 'hold_key' + | 'hold_encrypt' + | 'hold_decrypt' + | 'hold_sign' + | 'wrong_key' + | 'refuse_encrypt' + | 'refuse_decrypt' + | 'refuse_sign' + | 'wrong_encrypt' + | 'wrong_decrypt' + | 'wrong_sign_author' + | 'wrong_sign_time' + | 'wrong_sign_tags' + | 'cached_signature' + | 'stop_encrypt_getter' + | 'stop_decrypt_getter'; +type Provider = { + 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>; + }; +}; +// Actual source owners/SDK/Chromium storage and random keys, controlled provider +// and anonymous discovery transport. No installed extension/operator/Q evidence. +export async function makeProbeFixture() { + const base = await makeControllerFixture(true), + opened = await openBrowserDatabase(); + if (opened.state !== 'ready') + throw Error('native fixture database unavailable'); + const database = opened.owner, + repository = createPrivateStorageRepository(database, base.owner); + if (!repository) throw Error('actual private namespace'); + const provider = Reflect.get(window, 'nostr') as Provider; + const key = provider.getPublicKey.bind(provider), + sign = provider.signEvent.bind(provider), + encrypt = provider.nip44.encrypt.bind(provider.nip44), + decrypt = provider.nip44.decrypt.bind(provider.nip44); + let mode: Mode = 'normal', + release: (() => void) | undefined, + waiting = '', + keys = 0, + encrypts = 0, + decrypts = 0, + signs = 0; + let controller: Awaited<ReturnType<typeof base.capture>> | undefined, + identity: InboxProbeIdentity | undefined, + operation: InboxProbeSealOperation | undefined, + seal: InboxProbeRecipientSeal | undefined, + wrap: InboxProbeGiftwrap | undefined; + async function pause(stage: string) { + if (mode !== 'hold_' + stage) return; + waiting = stage; + await new Promise<void>((resolve) => { + release = resolve; + }); + waiting = ''; + release = undefined; + } + provider.getPublicKey = async () => { + keys++; + await pause('key'); + return mode === 'wrong_key' ? 'f'.repeat(64) : key(); + }; + provider.signEvent = async (input) => { + signs++; + await pause('sign'); + if (mode === 'refuse_sign') throw Error('controlled refusal'); + const changed = + mode === 'wrong_sign_time' + ? { ...input, created_at: input.created_at + 1 } + : mode === 'wrong_sign_tags' + ? { ...input, tags: [['p', base.owner]] } + : input; + if (mode === 'wrong_sign_author') base.mode('author'); + let response: Record<string, unknown>; + try { + response = await sign(changed); + } finally { + base.mode('exact'); + } + return mode === 'cached_signature' + ? { ...response, sig: '0'.repeat(128) } + : response; + }; + Object.defineProperty(provider, 'nip44', { + configurable: true, + value: { + get encrypt() { + if (mode === 'stop_encrypt_getter' && controller) + closeInboxAccessController(controller); + return async (target: string, wire: string) => { + encrypts++; + await pause('encrypt'); + if (mode === 'refuse_encrypt') throw Error('controlled refusal'); + return encrypt( + target, + mode === 'wrong_encrypt' ? 'substituted rumor' : wire + ); + }; + }, + get decrypt() { + if (mode === 'stop_decrypt_getter' && controller) + closeInboxAccessController(controller); + return async (target: string, wire: string) => { + decrypts++; + await pause('decrypt'); + if (mode === 'refuse_decrypt') throw Error('controlled refusal'); + return mode === 'wrong_decrypt' + ? 'substituted plaintext' + : decrypt(target, wire); + }; + } + } + }); + const operator = (unsupported = false, unconfigured = false) => { + const value = validateInboxOperatorQualification( + JSON.stringify({ + schemaVersion: 1, + revision: 1, + authority: unconfigured ? 'unconfigured' : 'source_fixture', + policyWire: JSON.stringify(readRelayPolicy(base.policy)), + evidenceSha256: unconfigured ? null : 'a'.repeat(64), + relays: unconfigured + ? [] + : readRelayPolicy(base.policy).inbox.map(({ origin }) => ({ + origin, + auth: 'not_required', + recipientRead: 'supported', + namedArchiveAck: 'supported', + exactReadback: unsupported ? 'unsupported' : 'supported', + retention: 'operator_defined' + })) + }) + ); + if (!value) throw Error('source-labelled operator fixture'); + return value; + }; + const qualification = operator(); + let otherIdentity: ReturnType<typeof createIdentitySession> | undefined, + otherSession: PrivateSession | undefined; + async function stored() { + const tx = browserDatabaseTransaction( + database, + ['private_sends'], + 'readonly' + ), + req = tx.objectStore('private_sends').getAll(); + return new Promise<{ owner: string; id: string; wire: string }[]>( + (resolve, reject) => { + tx.addEventListener('complete', () => + resolve(req.result as { owner: string; id: string; wire: string }[]) + ); + tx.addEventListener('abort', () => reject(Error('inspection aborted'))); + } + ); + } + return { + ...base, + repository, + qualification, + operator, + foreignRepository() { + const secret = generateSecretKey(), + owner = getPublicKey(secret); + secret.fill(0); + const result = createPrivateStorageRepository(database, owner); + if (!result) throw Error('actual foreign namespace'); + return result; + }, + copiedPolicy() { + const result = validateRelayPolicy( + JSON.stringify(readRelayPolicy(base.policy)) + ); + if (!result) throw Error('genuine alternate policy token'); + return result; + }, + async foreignSession() { + otherIdentity = createIdentitySession(); + await connectIdentity(otherIdentity); + await probeIdentityMessaging(otherIdentity, 'reviewed_self_copy'); + otherSession = await createPrivateSession( + otherIdentity, + 'reviewed_private_session' + ); + if (!otherSession) throw Error('genuine same-owner other session'); + return otherSession; + }, + async capture() { + controller = await base.capture(); + return controller; + }, + controller: () => controller, + probeIdentity: () => identity, + operation: () => operation, + seal: () => seal, + wrap: () => wrap, + mode(next: Mode) { + mode = next; + }, + waiting: () => waiting, + settle: () => release?.(), + counts: () => ({ keys, encrypts, decrypts, signs }), + stored, + async fillCapacity() { + const secret = generateSecretKey(), + peer = getPublicKey(secret); + secret.fill(0); + const tx = browserDatabaseTransaction( + database, + ['private_sends'], + 'readwrite' + ), + store = tx.objectStore('private_sends'); + for (let i = 0; i < 100; i++) { + const id = crypto.randomUUID(); + store.put({ + owner: base.owner, + id, + wire: JSON.stringify({ + schema: 1, + family: 'private_send_reservation', + owner: base.owner, + id, + revision: 0, + peer, + rumorHash: 'a'.repeat(64), + createdAt: 1 + }) + }); + } + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => + reject(Error('fixture capacity abort')) + ); + }); + }, + installNativeAbort() { + const original = Object.getOwnPropertyDescriptor( + IDBObjectStore.prototype, + 'put' + )?.value as IDBObjectStore['put']; + let fired = false; + IDBObjectStore.prototype.put = function ( + ...args: Parameters<IDBObjectStore['put']> + ) { + const request = original.apply(this, args); + if (!fired && this.name === 'private_sends') { + fired = true; + const transaction = this.transaction; + request.addEventListener('success', () => transaction.abort()); + } + return request; + }; + return () => { + IDBObjectStore.prototype.put = original; + }; + }, + installChangedReadback() { + const original = Object.getOwnPropertyDescriptor( + IDBDatabase.prototype, + 'transaction' + )?.value as IDBDatabase['transaction']; + let fired = false; + IDBDatabase.prototype.transaction = function ( + ...args: Parameters<IDBDatabase['transaction']> + ) { + const tx = original.apply(this, args); + if ( + !fired && + args[1] === 'readwrite' && + tx.objectStoreNames.contains('private_sends') + ) { + fired = true; + tx.addEventListener('complete', () => { + const next = original.call(this, ['private_sends'], 'readwrite'), + store = next.objectStore('private_sends'), + rows = store.getAll(); + rows.addEventListener('success', () => { + for (const row of rows.result as { + owner: string; + id: string; + wire: string; + }[]) { + if (row.owner !== base.owner) continue; + const parsed = JSON.parse(row.wire) as { createdAt: number }; + parsed.createdAt++; + store.put({ ...row, wire: JSON.stringify(parsed) }); + } + }); + }); + } + return tx; + }; + return () => { + IDBDatabase.prototype.transaction = original; + }; + }, + async reserve( + selected: InboxOperatorQualification = qualification, + review = 'reviewed_inbox_probe_reservation' + ) { + if (!controller) throw Error('missing genuine controller'); + const result = await reserveInboxProbeIdentity( + repository, + base.session, + base.policy, + controller, + selected, + review + ); + if ('identity' in result) identity = result.identity; + return { + status: result.status, + disposition: result.disposition, + snapshot: identity && inboxProbeSnapshot(identity) + }; + }, + async prepareSeal() { + if (!identity) throw Error('missing genuine reserved probe'); + operation = captureInboxProbeSealOperation( + base.session, + identity, + 'reviewed_inbox_probe_seal' + ); + if (!operation) return 'unavailable'; + const result = await buildInboxProbeSeal(operation); + if (result.status === 'sealed') { + seal = result.seal; + return 'sealed'; + } + return result.status; + }, + wrapOriginal() { + if (!seal) throw Error('missing genuine original seal'); + wrap = buildInboxProbeGiftwrap(seal, 'reviewed_inbox_probe_wrap'); + return wrap ? 'wrapped' : 'wrap_failed'; + }, + async prepare() { + const result = await this.prepareSeal(); + return result === 'sealed' ? this.wrapOriginal() : result; + }, + installWrapFault() { + const original = Object.getOwnPropertyDescriptor(nip44.v2, 'encrypt') + ?.value as typeof nip44.v2.encrypt; + let failing = true, + calls = 0; + nip44.v2.encrypt = (...args: Parameters<typeof nip44.v2.encrypt>) => { + calls++; + if (failing) throw Error('controlled SDK wrapper failure'); + return original.apply(nip44.v2, args); + }; + return { + allow: () => { + failing = false; + }, + calls: () => calls, + restore: () => { + nip44.v2.encrypt = original; + } + }; + }, + async decryptOriginal() { + if (!identity || !wrap) throw Error('missing genuine artifact'); + const snapshot = inboxProbeSnapshot(identity), + artifact = inboxProbeGiftwrapSnapshot(wrap), + original = inboxProbeRumorWire(identity, base.session); + if (!snapshot || !artifact || !original) + throw Error('stale actual artifact'); + const outer = JSON.parse(artifact.wire) as { + pubkey: string; + content: string; + }, + sealWire = await decrypt(outer.pubkey, outer.content), + signed = verifyEnvelope(sealWire), + nested = JSON.parse(sealWire) as { pubkey: string; content: string }, + rumorWire = await decrypt(nested.pubkey, nested.content), + rumor = JSON.parse(rumorWire) as UnsignedEvent & { id: string }; + return { + outerVerified: verifyEnvelope(artifact.wire).ok, + sealVerified: signed.ok, + exactRumor: rumorWire === original, + hash: + getEventHash(rumor) === snapshot.rumorHash && + rumor.id === snapshot.rumorHash, + owner: rumor.pubkey === base.owner, + recipient: + JSON.stringify(rumor.tags) === JSON.stringify([['p', base.owner]]), + createdAt: rumor.created_at === snapshot.createdAt, + kind: rumor.kind, + diagnostic: + /^Harvestcircle private inbox access check v1: [0-9a-f]{64}$/.test( + rumor.content + ) + }; + }, + close() { + release?.(); + if (otherSession) closePrivateSession(otherSession); + if (otherIdentity) disconnectIdentity(otherIdentity); + base.close(); + closeBrowserDatabase(database); + } + }; +} +import { closeInboxAccessController } from '../../../src/lib/messaging/inbox-access-controller.ts'; diff --git a/web/tests/e2e/inbox-probe.spec.ts b/web/tests/e2e/inbox-probe.spec.ts @@ -0,0 +1,646 @@ +import { test, expect } from '@playwright/test'; +import { build } from 'vite'; +import { once } from 'node:events'; +import { fileURLToPath } from 'node:url'; +import { WebSocketServer } from 'ws'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/inbox-probe.ts'; +declare global { + interface Window { + p8: typeof Fixture; + p8Fixture: Awaited<ReturnType<typeof Fixture.makeProbeFixture>>; + p8Pending?: Promise<string>; + p8Restore?: () => void; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, + sockets: WebSocketServer, + endpoint: string, + bundle: string; +let head = ''; +const frames: 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('owned fixture relay'); + endpoint = 'ws://127.0.0.1:' + address.port; + sockets.on('connection', (socket) => { + 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(frame); + if (frame[0] === 'REQ') { + const filter = frame[2] as { kinds?: number[] }; + if (filter.kinds?.includes(10050) && head) + socket.send(JSON.stringify(['EVENT', frame[1], JSON.parse(head)])); + socket.send(JSON.stringify(['EOSE', frame[1]])); + } + }); + }); + const result = await build({ + configFile: false, + logLevel: 'silent', + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/inbox-probe.ts', import.meta.url) + ), + name: 'p8', + formats: ['iife'] + } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw Error('actual bundle'); + const chunks = output.output.filter((chunk) => chunk.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(() => sockets.clients.size).toBe(0); + head = ''; + frames.length = 0; + await page.addInitScript( + ({ endpoint }) => { + const Native = window.WebSocket; + window.WebSocket = class extends Native { + constructor(url: string | URL, protocols?: string | string[]) { + if (new URL(String(url)).origin !== 'wss://discovery.example.org') + throw Error('construction attempted private transport'); + super(endpoint, protocols); + } + }; + }, + { endpoint } + ); + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + head = await page.evaluate(async () => { + window.p8Fixture = await window.p8.makeProbeFixture(); + return window.p8Fixture.preferenceWire(['wss://inbox.example.org']); + }); + await page.evaluate(() => window.p8Fixture.capture()); +}); +test.afterEach(async ({ page }) => { + if (!page.isClosed()) + await page.evaluate(() => { + window.p8Restore?.(); + window.p8Fixture.close(); + }); +}); + +test('cold genuine self diagnostic reserves native metadata before prompts and decrypts the exact original SDK layers', async ({ + page +}) => { + const before = await page.evaluate(() => window.p8Fixture.counts()); + // Evaluate the native promise explicitly; there was no earlier ordinary send. + expect(await page.evaluate(() => window.p8Fixture.stored())).toHaveLength(0); + const reservation = await page.evaluate(() => window.p8Fixture.reserve()); + expect(reservation.status).toBe('reserved'); + const saved = await page.evaluate(() => window.p8Fixture.stored()); + expect(saved).toHaveLength(1); + expect(JSON.stringify(saved)).not.toContain( + 'Harvestcircle private inbox access check' + ); + expect(JSON.parse(saved[0].wire)).toMatchObject({ + family: 'private_access_probe', + revision: 0, + self: null, + receipts: [] + }); + expect(await page.evaluate(() => window.p8Fixture.counts())).toEqual(before); + expect(await page.evaluate(() => window.p8Fixture.prepare())).toBe('wrapped'); + expect(await page.evaluate(() => window.p8Fixture.decryptOriginal())).toEqual( + { + outerVerified: true, + sealVerified: true, + exactRumor: true, + hash: true, + owner: true, + recipient: true, + createdAt: true, + kind: 14, + diagnostic: true + } + ); + expect(await page.evaluate(() => window.p8Fixture.stored())).toEqual(saved); + const duplicate = await page.evaluate(() => window.p8Fixture.reserve()); + expect(duplicate.status).toBe('existing'); + expect(duplicate.snapshot).toEqual(reservation.snapshot); + expect( + await page.evaluate( + () => + window.p8.inboxAccessControllerSnapshot(window.p8Fixture.controller()!) + ?.readiness + ) + ).toBe('unavailable'); + expect( + frames.some((frame) => ['EVENT', 'AUTH'].includes(String(frame[0]))) + ).toBe(false); + expect( + frames + .filter((frame) => frame[0] === 'REQ') + .every((frame) => (frame[2] as { kinds: number[] }).kinds.includes(10050)) + ).toBe(true); +}); + +test('separate genuine maps reject ordinary adoption, copied snapshots and replacement crypto artifacts', async ({ + page +}) => { + await page.evaluate(() => window.p8Fixture.reserve()); + expect(await page.evaluate(() => window.p8Fixture.prepare())).toBe('wrapped'); + const result = await page.evaluate(async () => { + const f = window.p8Fixture, + api = window.p8, + identity = f.probeIdentity()!, + seal = f.seal()!, + wrap = f.wrap()!, + operation = f.operation()!; + const same = api.buildInboxProbeGiftwrap(seal, 'reviewed_inbox_probe_wrap'); + const reserved = identity as unknown as Parameters< + typeof api.capturePrivateSealOperation + >[1]; + const ordinarySeal = seal as unknown as Parameters< + typeof api.privateSealSnapshot + >[0]; + const ordinaryWrap = wrap as unknown as Parameters< + typeof api.privateGiftwrapSnapshot + >[0]; + const copy = api.inboxProbeSnapshot(identity)! as unknown as Parameters< + typeof api.captureInboxProbeSealOperation + >[1]; + return { + sameWrap: same === wrap, + sameOperation: + api.captureInboxProbeSealOperation( + f.session, + identity, + 'reviewed_inbox_probe_seal' + ) === operation, + duplicateRun: (await api.buildInboxProbeSeal(operation)).status, + ordinaryIdentity: api.reservedSendSnapshot(reserved) === undefined, + ordinaryCapture: + api.capturePrivateSealOperation( + f.identity, + reserved, + 'self', + 'reviewed_private_seal' + ) === undefined, + ordinaryRun: ( + await api.buildPrivateSeal( + operation as unknown as Parameters<typeof api.buildPrivateSeal>[0] + ) + ).status, + ordinarySeal: + api.privateSealSnapshot(ordinarySeal) === undefined && + api.privateSealReservation(ordinarySeal) === undefined, + ordinaryWrap: + api.buildPrivateGiftwrap(ordinarySeal, 'reviewed_private_wrap') === + undefined && api.privateGiftwrapSnapshot(ordinaryWrap) === undefined, + outbound: + api.verifyOutboundEnvelope( + reserved, + ordinaryWrap, + 'reviewed_outbound_layers' + ) === undefined, + copy: + api.captureInboxProbeSealOperation( + f.session, + copy, + 'reviewed_inbox_probe_seal' + ) === undefined + }; + }); + expect(result).toEqual({ + sameWrap: true, + sameOperation: true, + duplicateRun: 'stopped', + ordinaryIdentity: true, + ordinaryCapture: true, + ordinaryRun: 'invalid', + ordinarySeal: true, + ordinaryWrap: true, + outbound: true, + copy: true + }); +}); + +test('simultaneous genuine reservation returns busy while pending and creates exactly one native original', async ({ + page +}) => { + const result = await page.evaluate(async () => { + const f = window.p8Fixture, + first = f.reserve(), + second = f.reserve(), + [a, b] = await Promise.all([first, second]); + return { + a, + b, + rows: await f.stored(), + counts: f.counts(), + duplicate: await f.reserve() + }; + }); + expect(result.a.status).toBe('reserved'); + expect(result.b).toMatchObject({ + status: 'busy', + disposition: 'not_created' + }); + expect(result.rows).toHaveLength(1); + expect(result.rows[0].id).toBe(result.a.snapshot?.id); + expect(result.duplicate.status).toBe('existing'); + expect(result.duplicate.snapshot).toEqual(result.a.snapshot); + expect(result.counts).toEqual({ + keys: 0, + encrypts: 0, + decrypts: 0, + signs: 0 + }); +}); + +test('failed original probe wrapping stays protected and cannot mint a replacement after SDK recovery', async ({ + page +}) => { + await page.evaluate(() => window.p8Fixture.reserve()); + expect(await page.evaluate(() => window.p8Fixture.prepareSeal())).toBe( + 'sealed' + ); + const result = await page.evaluate(() => { + const api = window.p8, + f = window.p8Fixture, + fault = f.installWrapFault(); + window.p8Restore = () => fault.restore(); + const first = f.wrapOriginal(); + fault.allow(); + const second = f.wrapOriginal(); + return { + first, + second, + calls: fault.calls(), + sealCurrent: api.inboxProbeSealSnapshot(f.seal()!) !== undefined, + noWrap: f.wrap() === undefined, + noReplacement: + api.buildInboxProbeGiftwrap(f.seal()!, 'reviewed_inbox_probe_wrap') === + undefined + }; + }); + expect(result).toEqual({ + first: 'wrap_failed', + second: 'wrap_failed', + calls: 1, + sealCurrent: true, + noWrap: true, + noReplacement: true + }); + const rows = await page.evaluate(() => window.p8Fixture.stored()); + expect(rows).toHaveLength(1); + expect(JSON.parse(rows[0].wire)).toMatchObject({ + family: 'private_access_probe', + revision: 0, + self: null, + receipts: [] + }); + expect( + frames.some((frame) => ['EVENT', 'AUTH'].includes(String(frame[0]))) + ).toBe(false); +}); + +test('controller close rejects reentry, clears the original nonce first and retries only failed cleanup', async ({ + page +}) => { + await page.evaluate(() => window.p8Fixture.reserve()); + const original = await page.evaluate(() => window.p8Fixture.stored()); + const result = await page.evaluate(() => { + const api = window.p8, + f = window.p8Fixture, + controller = f.controller()!; + let calls = 0, + nested: boolean | undefined, + failing = true, + cleared = false; + const off = api.subscribeInboxAccessControllerClose(controller, () => { + calls++; + cleared = + api.inboxProbeRumorWire(f.probeIdentity()!, f.session) === undefined; + nested = api.closeInboxAccessController(controller); + if (failing) throw Error('controlled original cleanup fault'); + }); + const first = api.closeInboxAccessController(controller), + firstCleanup = + api.inboxAccessControllerSnapshot(controller)?.cleanupRequired; + failing = false; + const second = api.closeInboxAccessController(controller), + secondCleanup = + api.inboxAccessControllerSnapshot(controller)?.cleanupRequired; + off(); + return { + first, + firstCleanup, + second, + secondCleanup, + calls, + nested, + cleared + }; + }); + expect(result).toEqual({ + first: false, + firstCleanup: true, + second: true, + secondCleanup: false, + calls: 2, + nested: false, + cleared: true + }); + expect(await page.evaluate(() => window.p8Fixture.stored())).toEqual( + original + ); + expect(await page.evaluate(() => window.p8Fixture.reserve())).toMatchObject({ + status: 'stopped', + disposition: 'may_exist' + }); +}); + +test('unsupported and unconfigured declarations refuse before rows, provider work or private transport', async ({ + page +}) => { + const before = await page.evaluate(() => window.p8Fixture.counts()); + for (const selected of ['unsupported', 'unconfigured'] as const) { + const result = await page.evaluate( + (selected) => + window.p8Fixture.reserve( + window.p8Fixture.operator( + selected === 'unsupported', + selected === 'unconfigured' + ) + ), + selected + ); + expect(result).toMatchObject({ + status: 'unavailable', + disposition: 'not_created' + }); + } + expect(await page.evaluate(() => window.p8Fixture.stored())).toHaveLength(0); + expect(await page.evaluate(() => window.p8Fixture.counts())).toEqual(before); +}); + +test('foreign namespace and forged owner/config inputs cannot reserve or observe a provider', async ({ + page +}) => { + const result = await page.evaluate(async () => { + const f = window.p8Fixture, + api = window.p8, + before = f.counts(); + const fake = Object.freeze({ owner: f.owner, current: () => true }); + const reservation = await api.reserveInboxProbeIdentity( + fake as unknown as Parameters<typeof api.reserveInboxProbeIdentity>[0], + f.session, + f.policy, + f.controller()!, + f.qualification, + 'reviewed_inbox_probe_reservation' + ); + const forged = await api.reserveInboxProbeIdentity( + f.repository, + fake as unknown as Parameters<typeof api.reserveInboxProbeIdentity>[1], + f.policy, + f.controller()!, + f.qualification, + 'reviewed_inbox_probe_reservation' + ); + const config = await api.reserveInboxProbeIdentity( + f.repository, + f.session, + f.policy, + f.controller()!, + fake as unknown as Parameters<typeof api.reserveInboxProbeIdentity>[4], + 'reviewed_inbox_probe_reservation' + ); + return { + reservation, + forged, + config, + before, + after: f.counts(), + rows: await f.stored() + }; + }); + expect(result.reservation).toMatchObject({ + status: 'invalid_scope', + disposition: 'not_created' + }); + expect(result.forged).toMatchObject({ + status: 'invalid_scope', + disposition: 'not_created' + }); + expect(result.config).toMatchObject({ + status: 'unavailable', + disposition: 'not_created' + }); + expect(result.before).toEqual(result.after); + expect(result.rows).toHaveLength(0); +}); + +test('genuine foreign namespace, same-owner session and distinct policy cannot borrow the original controller', async ({ + page +}) => { + const result = await page.evaluate(async () => { + const f = window.p8Fixture, + api = window.p8, + session = await f.foreignSession(), + before = f.counts(); + const invoke = ( + repository: Parameters<typeof api.reserveInboxProbeIdentity>[0], + session: Parameters<typeof api.reserveInboxProbeIdentity>[1], + policy: Parameters<typeof api.reserveInboxProbeIdentity>[2] + ) => + api.reserveInboxProbeIdentity( + repository, + session, + policy, + f.controller()!, + f.qualification, + 'reviewed_inbox_probe_reservation' + ); + return { + namespace: await invoke(f.foreignRepository(), f.session, f.policy), + session: await invoke(f.repository, session, f.policy), + policy: await invoke(f.repository, f.session, f.copiedPolicy()), + before, + after: f.counts(), + rows: await f.stored() + }; + }); + for (const disposition of [result.namespace, result.session, result.policy]) + expect(disposition).toEqual({ + status: 'invalid_scope', + disposition: 'not_created' + }); + expect(result.before).toEqual(result.after); + expect(result.rows).toHaveLength(0); +}); + +test('native put success followed by abort gives no identity, row or crypto permission', async ({ + page +}) => { + await page.evaluate(() => { + window.p8Restore = window.p8Fixture.installNativeAbort(); + }); + expect(await page.evaluate(() => window.p8Fixture.reserve())).toMatchObject({ + status: 'aborted', + disposition: 'not_created' + }); + expect(await page.evaluate(() => window.p8Fixture.stored())).toHaveLength(0); + expect( + await page.evaluate(() => window.p8Fixture.probeIdentity()) + ).toBeUndefined(); + expect(await page.evaluate(() => window.p8Fixture.counts())).toEqual({ + keys: 0, + encrypts: 0, + decrypts: 0, + signs: 0 + }); +}); + +test('actual competing native write before readonly reconciliation cannot issue an original identity', async ({ + page +}) => { + await page.evaluate(() => { + window.p8Restore = window.p8Fixture.installChangedReadback(); + }); + expect(await page.evaluate(() => window.p8Fixture.reserve())).toMatchObject({ + status: 'conflict', + disposition: 'may_exist' + }); + expect(await page.evaluate(() => window.p8Fixture.stored())).toHaveLength(1); + expect( + await page.evaluate(() => window.p8Fixture.probeIdentity()) + ).toBeUndefined(); + expect(await page.evaluate(() => window.p8Fixture.counts())).toEqual({ + keys: 0, + encrypts: 0, + decrypts: 0, + signs: 0 + }); +}); + +test('the genuine reservation respects the existing full joint native quota before prompts', async ({ + page +}) => { + await page.evaluate(() => window.p8Fixture.fillCapacity()); + expect(await page.evaluate(() => window.p8Fixture.reserve())).toMatchObject({ + status: 'capacity', + disposition: 'not_created' + }); + expect(await page.evaluate(() => window.p8Fixture.stored())).toHaveLength( + 100 + ); + expect(await page.evaluate(() => window.p8Fixture.counts())).toEqual({ + keys: 0, + encrypts: 0, + decrypts: 0, + signs: 0 + }); +}); + +for (const mode of [ + 'wrong_key', + 'refuse_encrypt', + 'refuse_decrypt', + 'refuse_sign', + 'wrong_encrypt', + 'wrong_decrypt', + 'wrong_sign_author', + 'wrong_sign_time', + 'wrong_sign_tags', + 'cached_signature', + 'stop_encrypt_getter', + 'stop_decrypt_getter' +] as const) { + test(`genuine construction rejects ${mode} without any probe EVENT`, async ({ + page + }) => { + await page.evaluate(() => window.p8Fixture.reserve()); + const rows = await page.evaluate(() => window.p8Fixture.stored()); + await page.evaluate((mode) => window.p8Fixture.mode(mode), mode); + expect(await page.evaluate(() => window.p8Fixture.prepare())).not.toBe( + 'wrapped' + ); + expect(await page.evaluate(() => window.p8Fixture.wrap())).toBeUndefined(); + expect(await page.evaluate(() => window.p8Fixture.stored())).toEqual(rows); + expect( + frames.some((frame) => ['EVENT', 'AUTH'].includes(String(frame[0]))) + ).toBe(false); + if (mode.startsWith('stop_')) + expect(await page.evaluate(() => window.p8Fixture.counts())).toEqual({ + keys: 0, + encrypts: 0, + decrypts: 0, + signs: 0 + }); + }); +} + +for (const stage of ['key', 'encrypt', 'decrypt', 'sign'] as const) { + for (const invalidation of ['stop', 'head', 'session'] as const) { + test(`pending ${stage} remains owned and late results are fenced after ${invalidation}`, async ({ + page + }) => { + await page.evaluate(() => window.p8Fixture.reserve()); + const rows = await page.evaluate(() => window.p8Fixture.stored()); + await page.evaluate((stage) => { + window.p8Fixture.mode(('hold_' + stage) as Fixture.Mode); + window.p8Pending = window.p8Fixture.prepare(); + }, stage); + await expect + .poll(() => page.evaluate(() => window.p8Fixture.waiting())) + .toBe(stage); + const observed = await page.evaluate((invalidation) => { + const api = window.p8, + f = window.p8Fixture; + if (invalidation === 'stop') api.stopInboxProbeSeal(f.operation()!); + else if (invalidation === 'head') f.churnHead(); + else f.logout(); + return { + identity: api.inboxProbeSnapshot(f.probeIdentity()!) === undefined, + wire: + api.inboxProbeRumorWire(f.probeIdentity()!, f.session) === undefined + }; + }, invalidation); + expect(observed).toEqual({ identity: true, wire: true }); + await page.evaluate(() => window.p8Fixture.settle()); + expect(await page.evaluate(() => window.p8Pending)).toBe('stopped'); + expect( + await page.evaluate(() => window.p8Fixture.wrap()) + ).toBeUndefined(); + expect(await page.evaluate(() => window.p8Fixture.stored())).toEqual( + rows + ); + expect( + await page.evaluate(() => window.p8Fixture.reserve()) + ).toMatchObject({ status: 'stopped', disposition: 'may_exist' }); + expect( + frames.some((frame) => ['EVENT', 'AUTH'].includes(String(frame[0]))) + ).toBe(false); + }); + } +} diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -1937,6 +1937,9 @@ import { auditOutput } from '../../tools/check-output.mjs'; ); } for (const producer of [ + 'src/lib/nostr/inbox-access.ts', + 'src/lib/nostr/seal-builder.ts', + 'src/lib/nostr/giftwrap-builder.ts', 'src/lib/config/inbox-operators.ts', 'src/lib/persistence/private-sends.ts', 'src/lib/nostr/self-recovery-reader.ts', diff --git a/web/tests/provenance/source-boundaries.test.mjs b/web/tests/provenance/source-boundaries.test.mjs @@ -2246,6 +2246,14 @@ test( "review !== 'reviewed_private_wrap'", "review !== 'connect'" ), + source.replace( + "review !== 'reviewed_inbox_probe_wrap'", + "review !== 'connect'" + ), + source.replace( + 'record.destination !== record.owner', + 'record.destination !== record.destination' + ), source.replace("'applesauce-core/helpers'", "'nostr-tools/pure'") ]) { assert.notEqual(alteration, source); diff --git a/web/tests/unit/giftwrap-builder.test.ts b/web/tests/unit/giftwrap-builder.test.ts @@ -11,7 +11,8 @@ const state = vi.hoisted(() => ({ response: 'normal' })); vi.mock('../../src/lib/nostr/seal-builder.ts', () => ({ - privateSealSnapshot: (token: object) => state.seals.get(token) + privateSealSnapshot: (token: object) => state.seals.get(token), + inboxProbeSealSnapshot: () => undefined })); vi.mock('applesauce-core/helpers', async (original) => { const sdk = await original<typeof import('applesauce-core/helpers')>(); diff --git a/web/tests/unit/inbox-probe.test.ts b/web/tests/unit/inbox-probe.test.ts @@ -0,0 +1,113 @@ +import { afterEach, expect, it, vi } from 'vitest'; +import type { PrivateSession } from '../../src/lib/runtime/private-session.ts'; +import type { InboxAccessController } from '../../src/lib/messaging/inbox-access-controller.ts'; +import type { RelayPolicy } from '../../src/lib/config/relays.ts'; +import type { InboxOperatorQualification } from '../../src/lib/config/inbox-operators.ts'; +import type { PrivateStorageRepository } from '../../src/lib/persistence/private-storage.ts'; +import type { InboxProbeIdentity } from '../../src/lib/nostr/inbox-access.ts'; +import type { + InboxProbeRecipientSeal, + PrivateRecipientSeal, + PrivateSealOperation, + InboxProbeSealOperation +} from '../../src/lib/nostr/seal-builder.ts'; +import type { + InboxProbeGiftwrap, + PrivateGiftwrap +} from '../../src/lib/nostr/giftwrap-builder.ts'; + +afterEach(() => vi.unstubAllGlobals()); +it('cold SSR import resolves the real controller/publisher/builder cycle without browser effects', async () => { + vi.resetModules(); + expect(typeof window).toBe('undefined'); + // The repository SSR setup traps indexedDB/WebSocket/nostr/fetch accesses. + const probe = await import('../../src/lib/nostr/inbox-access.ts'); + const seal = await import('../../src/lib/nostr/seal-builder.ts'); + const wrap = await import('../../src/lib/nostr/giftwrap-builder.ts'); + expect(probe.inboxProbeSnapshot({} as InboxProbeIdentity)).toBeUndefined(); + expect( + await probe.reserveInboxProbeIdentity( + {} as PrivateStorageRepository, + {} as PrivateSession, + {} as RelayPolicy, + {} as InboxAccessController, + {} as InboxOperatorQualification, + 'reviewed_inbox_probe_reservation' + ) + ).toEqual({ status: 'invalid_scope', disposition: 'not_created' }); + expect( + seal.captureInboxProbeSealOperation( + {} as PrivateSession, + {} as InboxProbeIdentity, + 'reviewed_inbox_probe_seal' + ) + ).toBeUndefined(); + expect( + wrap.buildInboxProbeGiftwrap( + {} as InboxProbeRecipientSeal, + 'reviewed_inbox_probe_wrap' + ) + ).toBeUndefined(); +}); + +it('cold browser-shaped import and copied capabilities cannot observe a provider or storage', async () => { + vi.resetModules(); + let observations = 0; + vi.stubGlobal('window', { + get nostr() { + observations++; + throw Error('unreviewed provider observation'); + } + }); + vi.stubGlobal('navigator', { + get locks() { + observations++; + throw Error('unreviewed owner lock'); + } + }); + const probe = await import('../../src/lib/nostr/inbox-access.ts'); + const seal = await import('../../src/lib/nostr/seal-builder.ts'); + const wrap = await import('../../src/lib/nostr/giftwrap-builder.ts'); + const copy = Object.freeze({ owner: 'a'.repeat(64), current: () => true }); + expect( + await probe.reserveInboxProbeIdentity( + copy as unknown as PrivateStorageRepository, + copy as unknown as PrivateSession, + copy as unknown as RelayPolicy, + copy as unknown as InboxAccessController, + copy as unknown as InboxOperatorQualification, + 'reviewed_inbox_probe_reservation' + ) + ).toEqual({ status: 'invalid_scope', disposition: 'not_created' }); + expect( + await seal.buildInboxProbeSeal(copy as unknown as InboxProbeSealOperation) + ).toEqual({ status: 'invalid' }); + expect( + await seal.buildPrivateSeal(copy as unknown as PrivateSealOperation) + ).toEqual({ status: 'invalid' }); + expect( + seal.inboxProbeSealSnapshot(copy as unknown as InboxProbeRecipientSeal) + ).toBeUndefined(); + expect( + seal.privateSealSnapshot(copy as unknown as PrivateRecipientSeal) + ).toBeUndefined(); + expect( + wrap.buildInboxProbeGiftwrap( + copy as unknown as InboxProbeRecipientSeal, + 'reviewed_inbox_probe_wrap' + ) + ).toBeUndefined(); + expect( + wrap.buildPrivateGiftwrap( + copy as unknown as PrivateRecipientSeal, + 'reviewed_private_wrap' + ) + ).toBeUndefined(); + expect( + wrap.inboxProbeGiftwrapSnapshot(copy as unknown as InboxProbeGiftwrap) + ).toBeUndefined(); + expect( + wrap.privateGiftwrapSnapshot(copy as unknown as PrivateGiftwrap) + ).toBeUndefined(); + expect(observations).toBe(0); +}); diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -322,8 +322,14 @@ async function operationalFlagsAdmission(web) { 'b4c718364625b3caacbc5cc5f98bd79a575a5d66dddb2d7f59f03351a1308a6d', 'src/lib/nostr/inbox-ingress.ts': 'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb', + 'src/lib/nostr/inbox-access.ts': + 'fcd0a3aa216bd092b84e8ea1f4824f047367eaec6ed4e16715612554244eab0b', + 'src/lib/nostr/seal-builder.ts': + '3ccc967cc348e63857243ff6f0302c1a68da2afe85ca2c37e00d5a894785fc53', + 'src/lib/nostr/giftwrap-builder.ts': + 'faf54dd80a0995ac94b4b994d3cfd015516e5e201a1fbb6340e13c836ce49e98', 'src/lib/messaging/inbox-access-controller.ts': - 'c3093fe329575aba43333675c28352a6c0ddf24bcbc380c27f3a1ebab6252c5b', + '103c22b4cd721f7e3371ff887f4e7ca5df6a535688b9e9d0c67241db21430f9a', 'src/lib/messaging/inbox-setup-view.ts': 'e85238d20f1bbcb23599b36e67910f3df784efa43f0fa0b0b7f3da7e7fd33c79', 'src/lib/messaging/inbox-setup.ts': @@ -590,8 +596,14 @@ async function privacyDataAdmission(web) { 'b4c718364625b3caacbc5cc5f98bd79a575a5d66dddb2d7f59f03351a1308a6d', 'src/lib/nostr/inbox-ingress.ts': 'f860a094a8ba767585124c795d44b7620064f73a5b3a0170041c581c0fc64ecb', + 'src/lib/nostr/inbox-access.ts': + 'fcd0a3aa216bd092b84e8ea1f4824f047367eaec6ed4e16715612554244eab0b', + 'src/lib/nostr/seal-builder.ts': + '3ccc967cc348e63857243ff6f0302c1a68da2afe85ca2c37e00d5a894785fc53', + 'src/lib/nostr/giftwrap-builder.ts': + 'faf54dd80a0995ac94b4b994d3cfd015516e5e201a1fbb6340e13c836ce49e98', 'src/lib/messaging/inbox-access-controller.ts': - 'c3093fe329575aba43333675c28352a6c0ddf24bcbc380c27f3a1ebab6252c5b', + '103c22b4cd721f7e3371ff887f4e7ca5df6a535688b9e9d0c67241db21430f9a', 'src/lib/messaging/inbox-setup-view.ts': '4ec9025232bb1355fef1ba039b46ce0a2be10e02e348e1b4eaadc3d1f3c2fd84', 'src/lib/messaging/inbox-sync.ts': diff --git a/web/tools/source-boundaries.mjs b/web/tools/source-boundaries.mjs @@ -1618,7 +1618,7 @@ export async function auditSource(root) { const giftwrapTrusted = files.has(giftwrapFile) && createHash('sha256').update(files.get(giftwrapFile)).digest('hex') === - '866d53d993f40edc15828fcf279c03b35258cc3e5de8f555ac95339f846ac9f3'; + 'faf54dd80a0995ac94b4b994d3cfd015516e5e201a1fbb6340e13c836ce49e98'; if (files.has(giftwrapFile) && !giftwrapTrusted) complain( giftwrapFile,