commit ab68842e98d974d52c8a0169d556efe27d124e02
parent 601b9b59d003f72d0f01987625ec8e20ae3c98d5
Author: triesap <tyson@radroots.org>
Date: Wed, 14 Oct 2026 13:54:00 +0000
harvestcircle: verify original inbox probe nonce
- Share the guarded self decryption engine while preserving ordinary recovery.
- Bind nonce proofs to genuine readback, original sessions and exact native rows.
- Preserve pending SDK custody and stop scope loss before identity cleanup.
- Verify cold browser flows, hostile inputs and exact source output guards.
Diffstat:
6 files changed, 1784 insertions(+), 90 deletions(-)
diff --git a/web/src/lib/nostr/self-recovery-reader.ts b/web/src/lib/nostr/self-recovery-reader.ts
@@ -1,3 +1,19 @@
+import type { RelayPolicy } from '../config/relays.ts';
+import {
+ privateSessionOwnership,
+ subscribePrivateSessionClose,
+ type PrivateSession
+} from '../runtime/private-session.ts';
+import {
+ inboxProbeReadbackAttemptEvidence,
+ type InboxProbeReadbackAttemptResult
+} from './private-pool.ts';
+import {
+ inboxProbePublicationBinding,
+ type InboxProbeAcknowledgement
+} from '../persistence/inbox-probes.ts';
+import { inboxProbeRumorWire } from './inbox-access.ts';
+import { inboxProbeReadbackMatches } from '../persistence/private-records.ts';
import { ExtensionSigner } from 'applesauce-signers';
import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts';
import { canonicalLocalId } from '../private-handles.ts';
@@ -11,6 +27,7 @@ import {
} from '../runtime/identity-session.ts';
import {
loadPrivateRecord,
+ observePrivateRecord,
type PrivateStorageRepository,
type PrivateStorageFailure
} from '../persistence/private-storage.ts';
@@ -33,6 +50,111 @@ import {
markExtensionWaitExpired,
type ExtensionAction
} from './extension-scheduler.ts';
+// Module-private strict self-layer SDK engine. Only the two factory-owned reader
+// scopes below provide ownership/currentness; no caller cipher/event port exists.
+function strictSelfDecryptor(
+ identity: IdentitySession,
+ owner: string,
+ current: () => boolean
+) {
+ 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 !== owner
+ ) {
+ disconnectIdentity(identity);
+ return false;
+ }
+ const cipher = port();
+ // A callback may revoke only this scope. That cannot grant authority to
+ // disconnect an otherwise current identity and its independent consumers.
+ if (!current()) return false;
+ if (!cipher) {
+ disconnectIdentity(identity);
+ return false;
+ }
+ return current();
+ }
+ async function open(
+ action: ExtensionAction,
+ outer: import('applesauce-core/helpers').NostrEvent
+ ): Promise<
+ | Readonly<{ status: 'opened'; rumorWire: string; sealWire: string }>
+ | Readonly<{ status: 'stopped' | 'refused' | 'mismatch' }>
+ > {
+ 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,
+ verified = verifyEnvelope(sealWire),
+ seal = verified.ok && verifiedEnvelopeSnapshot(verified.value);
+ if (
+ !seal ||
+ seal.pubkey !== 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' };
+ return { status: 'opened', rumorWire: decrypted.value, sealWire };
+ }
+ return { fresh, open };
+}
+
declare const readerBrand: unique symbol;
declare const recoveredBrand: unique symbol;
export type SelfRecoveryReader = Readonly<{ [readerBrand]: true }>;
@@ -97,36 +219,8 @@ export function captureSelfRecoveryReader(
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();
- }
+ const decryptor = strictSelfDecryptor(session, ownership.owner, current);
+ const fresh = (action: ExtensionAction) => decryptor.fresh(action);
async function run(): Promise<SelfRecoveryReadResult> {
if (started || !current()) return { status: 'stopped' };
started = true;
@@ -199,65 +293,10 @@ export function captureSelfRecoveryReader(
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)
- );
+ const opened = await decryptor.open(action, outer);
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 (opened.status !== 'opened') return opened;
+ const { rumorWire, sealWire } = opened;
if (
!verifyOutboundLayerData(
rumorWire,
@@ -350,3 +389,400 @@ export function recoveredSelfEnvelopeSnapshot(
? (JSON.parse(JSON.stringify(saved.snapshot)) as Snapshot)
: undefined;
}
+
+declare const probeNonceReaderBrand: unique symbol;
+export type InboxProbeNonceReader = Readonly<{ [probeNonceReaderBrand]: true }>;
+declare const probeNonceProofBrand: unique symbol;
+export type InboxProbeNonceProof = Readonly<{ [probeNonceProofBrand]: true }>;
+export type InboxProbeNonceResult =
+ | Readonly<{ status: 'nonce_verified'; proof: InboxProbeNonceProof }>
+ | Readonly<{
+ status:
+ | PrivateStorageFailure
+ | 'invalid'
+ | 'stopped'
+ | 'busy'
+ | 'refused'
+ | 'mismatch'
+ | 'lost_evidence';
+ }>;
+type ProbeReader = {
+ run(): Promise<InboxProbeNonceResult>;
+ stop(expired: boolean): void;
+};
+const probeReaders = new WeakMap<InboxProbeNonceReader, ProbeReader>();
+const probeObservationReaders = new WeakMap<
+ InboxProbeReadbackAttemptResult,
+ Readonly<{
+ repository: PrivateStorageRepository;
+ identity: IdentitySession;
+ session: PrivateSession;
+ policy: RelayPolicy;
+ reader: InboxProbeNonceReader;
+ }>
+>();
+const probeNonceProofs = new WeakMap<
+ InboxProbeNonceProof,
+ Readonly<{
+ repository: PrivateStorageRepository;
+ session: PrivateSession;
+ policy: RelayPolicy;
+ observation: InboxProbeReadbackAttemptResult;
+ acknowledgement: InboxProbeAcknowledgement;
+ original: string;
+ current(): boolean;
+ }>
+>();
+function immutableProbe(
+ record: import('../persistence/private-records.ts').PrivateAccessProbe
+) {
+ return JSON.stringify({
+ owner: record.owner,
+ id: record.id,
+ rumorHash: record.rumorHash,
+ createdAt: record.createdAt,
+ binding: record.binding,
+ self: record.self
+ });
+}
+// Genuine positive source transport, actual identity/private session, original
+// nonce and native custody are all required. Capture never calls the provider.
+export function captureInboxProbeNonceReader(
+ repository: PrivateStorageRepository,
+ identity: IdentitySession,
+ session: PrivateSession,
+ policy: RelayPolicy,
+ observation: InboxProbeReadbackAttemptResult,
+ review: unknown
+): InboxProbeNonceReader | undefined {
+ if (
+ typeof window === 'undefined' ||
+ review !== 'reviewed_inbox_probe_nonce_decryption'
+ )
+ return undefined;
+ try {
+ const effect = inboxProbeReadbackAttemptEvidence(observation);
+ if (!effect || effect.repository !== repository) return undefined;
+ const acknowledgement = effect.acknowledgement,
+ binding = inboxProbePublicationBinding(
+ repository,
+ session,
+ acknowledgement,
+ policy
+ );
+ if (!binding?.record.self) return undefined;
+ const identityOwner = identityMessagingOwnership(identity);
+ if (
+ !identityOwner?.current() ||
+ binding.record.owner !== identityOwner.owner
+ )
+ return undefined;
+ const privateOwner = privateSessionOwnership(session);
+ if (
+ !privateOwner?.current() ||
+ identityOwner.owner !== privateOwner.owner ||
+ identityOwner.session !== privateOwner.session
+ )
+ return undefined;
+ const fact = JSON.parse(
+ effect.receiptWire
+ ) as import('../persistence/private-records.ts').PrivateAccessProbeReceipt;
+ if (
+ fact.role !== 'access_readback' ||
+ fact.status !== 'readback' ||
+ fact.eventId !== binding.record.self.eventId ||
+ !binding.record.binding.readTargets.includes(fact.origin) ||
+ !inboxProbeReadbackMatches(
+ binding.record.self,
+ binding.record.owner,
+ fact.readbackWire
+ ) ||
+ !inboxProbeRumorWire(binding.identity, session)
+ )
+ return undefined;
+ const previous = probeObservationReaders.get(observation);
+ if (previous)
+ return previous.repository === repository &&
+ previous.identity === identity &&
+ previous.session === session &&
+ previous.policy === policy
+ ? previous.reader
+ : undefined;
+ const original = immutableProbe(binding.record),
+ token = Object.freeze({}) as InboxProbeNonceReader;
+ let stopped = false,
+ started = false,
+ pending = false,
+ active: ExtensionAction | undefined,
+ proof: InboxProbeNonceProof | undefined,
+ last: InboxProbeNonceResult | undefined;
+ const listeners = new Map<symbol, () => void>();
+ function current() {
+ const fresh = inboxProbePublicationBinding(
+ repository,
+ session,
+ acknowledgement,
+ policy
+ );
+ return (
+ !stopped &&
+ identityOwner!.current() &&
+ privateOwner!.current() &&
+ !!fresh &&
+ fresh.identity === binding!.identity &&
+ immutableProbe(fresh.record) === original &&
+ !!inboxProbeRumorWire(fresh.identity, session)
+ );
+ }
+ function stop(expired: boolean) {
+ stopped = true;
+ if (active) {
+ if (expired) markExtensionWaitExpired(active);
+ else stopExtensionAction(active);
+ }
+ if (proof) probeNonceProofs.delete(proof);
+ proof = undefined;
+ for (const [id, off] of listeners) {
+ off();
+ listeners.delete(id);
+ }
+ }
+ function retain(register: () => () => void) {
+ const off = register();
+ if (stopped) off();
+ else listeners.set(Symbol(), off);
+ }
+ const decryptor = strictSelfDecryptor(
+ identity,
+ identityOwner.owner,
+ current
+ );
+ async function run(): Promise<InboxProbeNonceResult> {
+ if (!current()) {
+ stop(false);
+ return { status: 'stopped' };
+ }
+ if (pending) return { status: 'busy' };
+ if (started) return last ?? { status: 'stopped' };
+ started = true;
+ pending = true;
+ try {
+ if (!navigator.locks?.request)
+ return (last = { status: 'unavailable' });
+ last = await navigator.locks.request(
+ 'harvestcircle:owner:' + identityOwner!.owner,
+ { mode: 'exclusive', ifAvailable: true },
+ async (lock): Promise<InboxProbeNonceResult> => {
+ if (!lock) return { status: 'busy' };
+ if (!current()) return { status: 'stopped' };
+ const captured = inboxProbePublicationBinding(
+ repository,
+ session,
+ acknowledgement,
+ policy
+ );
+ if (!captured?.record.self) return { status: 'stopped' };
+ const loaded = await observePrivateRecord(
+ repository,
+ 'private_sends',
+ captured.record.id
+ );
+ if (!current()) return { status: 'stopped' };
+ if (!loaded.ok) return { status: loaded.reason };
+ if (
+ loaded.value.wire !== captured.wire ||
+ privateRecordWire(
+ loaded.value.handle,
+ captured.record.owner,
+ captured.record.id
+ ) !== captured.wire ||
+ inboxProbePublicationBinding(
+ repository,
+ session,
+ acknowledgement,
+ policy
+ )?.wire !== captured.wire
+ )
+ return { status: 'conflict' };
+ const checked = verifyEnvelope(captured.record.self.wire),
+ outer = checked.ok && verifiedEnvelopeSnapshot(checked.value);
+ if (
+ !outer ||
+ outer.kind !== 1059 ||
+ outer.id !== captured.record.self.eventId ||
+ JSON.stringify(outer.tags) !==
+ JSON.stringify([['p', captured.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: identityOwner!.owner,
+ session: identityOwner!.session,
+ operation: Symbol()
+ },
+ current,
+ async (action): Promise<InboxProbeNonceResult> => {
+ active = action;
+ const opened = await decryptor.open(action, outer);
+ if (!current()) return { status: 'stopped' };
+ if (opened.status !== 'opened') return opened;
+ const expected = inboxProbeRumorWire(
+ captured.identity,
+ session
+ );
+ if (!expected || opened.rumorWire !== expected)
+ return { status: 'mismatch' };
+ const rumor = JSON.parse(opened.rumorWire) as {
+ id: string;
+ created_at: number;
+ pubkey: string;
+ };
+ if (
+ rumor.id !== captured.record.rumorHash ||
+ rumor.created_at !== captured.record.createdAt ||
+ rumor.pubkey !== captured.record.owner
+ )
+ return { status: 'mismatch' };
+ // All callback-capable provider/cipher work finishes before the
+ // final physical read. No extension callback follows that read.
+ if (!(await decryptor.fresh(action)))
+ return { status: 'stopped' };
+ const after = await observePrivateRecord(
+ repository,
+ 'private_sends',
+ captured.record.id
+ );
+ if (!current()) return { status: 'stopped' };
+ if (!after.ok) return { status: after.reason };
+ if (
+ after.value.wire !== captured.wire ||
+ privateRecordWire(
+ after.value.handle,
+ captured.record.owner,
+ captured.record.id
+ ) !== captured.wire ||
+ inboxProbePublicationBinding(
+ repository,
+ session,
+ acknowledgement,
+ policy
+ )?.wire !== captured.wire
+ )
+ return { status: 'conflict' };
+ if (
+ !current() ||
+ inboxProbeRumorWire(captured.identity, session) !== expected
+ )
+ return { status: 'stopped' };
+ const issued = Object.freeze({}) as InboxProbeNonceProof;
+ probeNonceProofs.set(issued, {
+ repository,
+ session,
+ policy,
+ observation,
+ acknowledgement,
+ original,
+ current
+ });
+ proof = issued;
+ return { status: 'nonce_verified', proof: issued };
+ }
+ );
+ 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' };
+ }
+ );
+ return last;
+ } catch {
+ return (last = { status: current() ? 'refused' : 'stopped' });
+ } finally {
+ active = undefined;
+ pending = false;
+ }
+ }
+ probeReaders.set(token, { run, stop });
+ // Reserve before callback-capable subscriptions; reentrant capture reuses
+ // this exact original reader and cannot reset or start another SDK action.
+ probeObservationReaders.set(observation, {
+ repository,
+ identity,
+ session,
+ policy,
+ reader: token
+ });
+ retain(() =>
+ subscribeIdentityInvalidation(identity, () => {
+ if (!identityOwner.current()) stop(false);
+ })
+ );
+ retain(() => subscribePrivateSessionClose(session, () => stop(false)));
+ return current() ? token : undefined;
+ } catch {
+ return undefined;
+ }
+}
+export function readInboxProbeNonce(
+ reader: InboxProbeNonceReader
+): Promise<InboxProbeNonceResult> {
+ return (
+ probeReaders.get(reader)?.run() ?? Promise.resolve({ status: 'invalid' })
+ );
+}
+export function stopInboxProbeNonceReader(reader: InboxProbeNonceReader) {
+ probeReaders.get(reader)?.stop(false);
+}
+export function expireInboxProbeNonceReaderWait(reader: InboxProbeNonceReader) {
+ probeReaders.get(reader)?.stop(true);
+}
+export function inboxProbeNonceProofBinding(
+ proof: InboxProbeNonceProof,
+ repository: PrivateStorageRepository,
+ session: PrivateSession,
+ policy: RelayPolicy
+) {
+ const saved = probeNonceProofs.get(proof);
+ if (
+ !saved ||
+ saved.repository !== repository ||
+ saved.session !== session ||
+ saved.policy !== policy ||
+ !saved.current()
+ )
+ return undefined;
+ const binding = inboxProbePublicationBinding(
+ repository,
+ session,
+ saved.acknowledgement,
+ policy
+ );
+ if (!binding || immutableProbe(binding.record) !== saved.original)
+ return undefined;
+ return {
+ acknowledgement: saved.acknowledgement,
+ observation: saved.observation,
+ identity: binding.identity,
+ owner: binding.record.owner,
+ command: binding.record.id,
+ rumorHash: binding.record.rumorHash,
+ eventId: binding.record.self!.eventId,
+ current: () => saved.current()
+ };
+}
diff --git a/web/tests/e2e/harness/inbox-probe-nonce.ts b/web/tests/e2e/harness/inbox-probe-nonce.ts
@@ -0,0 +1,156 @@
+import { makeReadbackFixture } from './inbox-probe-readback.ts';
+import {
+ captureInboxProbeNonceReader,
+ readInboxProbeNonce,
+ inboxProbeNonceProofBinding,
+ stopInboxProbeNonceReader,
+ type InboxProbeNonceReader,
+ type InboxProbeNonceProof
+} from '../../../src/lib/nostr/self-recovery-reader.ts';
+import type { UnsignedEvent } from 'applesauce-core/helpers';
+export * from './inbox-probe-readback.ts';
+export * from '../../../src/lib/nostr/self-recovery-reader.ts';
+export * from '../../../src/lib/nostr/extension-scheduler.ts';
+export * from '../../../src/lib/runtime/identity-session.ts';
+export async function makeNonceFixture() {
+ const f = await makeReadbackFixture();
+ let reader: InboxProbeNonceReader | undefined,
+ proof: InboxProbeNonceProof | undefined;
+ const restores = new Map<symbol, () => void>();
+ function capture(review: unknown = 'reviewed_inbox_probe_nonce_decryption') {
+ const observed = f.lastRead();
+ return observed
+ ? captureInboxProbeNonceReader(
+ f.repository,
+ f.identity,
+ f.session,
+ f.policy,
+ observed,
+ review
+ )
+ : undefined;
+ }
+ type Provider = {
+ getPublicKey(): Promise<string>;
+ signEvent(input: UnsignedEvent): Promise<Record<string, unknown>>;
+ nip44: { decrypt(target: string, content: string): Promise<string> };
+ };
+ const provider = Reflect.get(window, 'nostr') as Provider;
+ function retain(restore: () => void) {
+ const id = Symbol();
+ restores.set(id, restore);
+ return () => {
+ restore();
+ restores.delete(id);
+ };
+ }
+ return {
+ ...f,
+ nonceCapture: capture,
+ nonceReader: () => reader,
+ nonceProof: () => proof,
+ proofBinding: () =>
+ proof &&
+ inboxProbeNonceProofBinding(proof, f.repository, f.session, f.policy),
+ async nonce(selected = (reader ??= capture())) {
+ if (!selected) return { status: 'invalid' as const };
+ reader ??= selected;
+ const result = await readInboxProbeNonce(selected);
+ if ('proof' in result) proof = result.proof;
+ return {
+ status: result.status,
+ proof: 'proof' in result ? result.proof : undefined
+ };
+ },
+ keyCallback(hit: number, callback: () => void | Promise<void>) {
+ const original = Object.getOwnPropertyDescriptor(
+ provider,
+ 'getPublicKey'
+ )!.value as Provider['getPublicKey'];
+ let n = 0;
+ provider.getPublicKey = async function () {
+ n++;
+ if (n === hit) await callback();
+ return original.call(this);
+ };
+ return retain(() => {
+ provider.getPublicKey = original;
+ });
+ },
+ cipherGetter(callback: () => void) {
+ const descriptor = Object.getOwnPropertyDescriptor(provider, 'nip44')!,
+ cipher = provider.nip44;
+ Object.defineProperty(provider, 'nip44', {
+ configurable: true,
+ get() {
+ callback();
+ return cipher;
+ }
+ });
+ return retain(() => {
+ Object.defineProperty(provider, 'nip44', descriptor);
+ });
+ },
+ decryptCallback(
+ hit: number,
+ transform: (wire: string) => string | Promise<string>
+ ) {
+ const cipher = provider.nip44,
+ descriptor = Object.getOwnPropertyDescriptor(cipher, 'decrypt')!,
+ original = cipher.decrypt.bind(cipher);
+ let n = 0,
+ receivers = 0;
+ Object.defineProperty(cipher, 'decrypt', {
+ configurable: true,
+ value: async function (
+ this: Provider['nip44'],
+ target: string,
+ content: string
+ ) {
+ if (this !== cipher) throw Error('wrong actual cipher receiver');
+ receivers++;
+ const wire = await original(target, content);
+ n++;
+ return n === hit ? transform(wire) : wire;
+ }
+ });
+ return {
+ receivers: () => receivers,
+ restore: retain(() => {
+ Object.defineProperty(cipher, 'decrypt', descriptor);
+ })
+ };
+ },
+ async changedNativeFact() {
+ const rows = await f.stored(),
+ row = rows.find((x) => x.id === f.snapshot()!.record.id)!;
+ const record = JSON.parse(row.wire) as {
+ revision: number;
+ receipts: unknown[];
+ };
+ record.revision++;
+ record.receipts.push(record.receipts[0]);
+ await f.inject([{ ...row, wire: JSON.stringify(record) }]);
+ },
+ async signSeal(wire: string, change: Record<string, unknown>) {
+ const seal = JSON.parse(wire) as UnsignedEvent;
+ const event = await provider.signEvent({
+ pubkey: seal.pubkey,
+ kind: seal.kind,
+ created_at: seal.created_at,
+ tags: seal.tags,
+ content: seal.content,
+ ...change
+ });
+ return JSON.stringify(event);
+ },
+ close() {
+ if (reader) stopInboxProbeNonceReader(reader);
+ for (const [id, off] of restores) {
+ off();
+ restores.delete(id);
+ }
+ f.close();
+ }
+ };
+}
diff --git a/web/tests/e2e/inbox-probe-nonce.spec.ts b/web/tests/e2e/inbox-probe-nonce.spec.ts
@@ -0,0 +1,1017 @@
+import { test, expect } from '@playwright/test';
+import { build } from 'vite';
+import { once } from 'node:events';
+import { fileURLToPath } from 'node:url';
+import { WebSocketServer, type WebSocket } from 'ws';
+import { createStaticHarness } from '../integration/harness/static.ts';
+import type * as Fixture from './harness/inbox-probe-nonce.ts';
+declare global {
+ interface Window {
+ nc: typeof Fixture;
+ ncFixture: Awaited<ReturnType<typeof Fixture.makeNonceFixture>>;
+ ncPending?: Promise<unknown>;
+ ncAbort?: AbortController;
+ ncOtherPool?: Fixture.PrivatePool;
+ ncRestore?: () => void;
+ ncAdvancePage?: () => void;
+ ncAdvanceOnSocket?: 'network' | 'page';
+ ncClock?: number;
+ ncNetworkClock?: ReturnType<Window['ncFixture']['installNetworkClock']>;
+ ncDelayClose?: boolean;
+ ncFailClose?: boolean;
+ ncInvalidateOnSocket?: boolean;
+ ncNestedCleanup?: number;
+ ncNestedFailure?: number;
+ ncHeldClose?: (() => void)[];
+ ncNoncePending?: Promise<unknown>;
+ ncNonceOther?: Promise<unknown>;
+ }
+}
+let server: Awaited<ReturnType<typeof createStaticHarness>>,
+ sockets: WebSocketServer,
+ endpoint: string,
+ bundle: string;
+let readMode = 'exact';
+const archived = new Map<string, Record<string, unknown>>();
+let head = '',
+ response: 'accepted' | 'refused' | 'unknown' | 'wrong' | 'auth_required' =
+ 'accepted',
+ auth = false;
+const frames: { origin: string; frame: unknown[] }[] = [],
+ physical = new Set<WebSocket>();
+let peak = 0,
+ privatePeak = 0;
+const privatePhysical = new Set<WebSocket>();
+const privateConnections = new Map<string, number>();
+test.beforeAll(async () => {
+ server = await createStaticHarness();
+ sockets = new WebSocketServer({
+ host: '127.0.0.1',
+ port: 0,
+ maxPayload: 65536
+ });
+ await once(sockets, 'listening');
+ const address = sockets.address();
+ if (!address || typeof address === 'string')
+ throw Error('actual loorback fixture');
+ endpoint = 'ws://127.0.0.1:' + address.port;
+ sockets.on('connection', (socket, request) => {
+ physical.add(socket);
+ peak = Math.max(peak, physical.size);
+ socket.on('close', () => physical.delete(socket));
+ const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get(
+ 'origin'
+ )!;
+ if (origin !== 'wss://discovery.example.org') {
+ privatePhysical.add(socket);
+ privateConnections.set(origin, (privateConnections.get(origin) ?? 0) + 1);
+ privatePeak = Math.max(privatePeak, privatePhysical.size);
+ socket.on('close', () => privatePhysical.delete(socket));
+ }
+ if (auth && origin === 'wss://inbox.example.org')
+ socket.send(JSON.stringify(['AUTH', 'probe-challenge']));
+ socket.on('message', (bytes) => {
+ const raw = Buffer.isBuffer(bytes)
+ ? bytes
+ : Array.isArray(bytes)
+ ? Buffer.concat(bytes)
+ : Buffer.from(bytes);
+ const frame = JSON.parse(raw.toString()) as unknown[];
+ frames.push({ origin, frame });
+ if (frame[0] === 'REQ') {
+ const filter = frame[2] as { kinds?: number[]; ids?: string[] };
+ if (filter.kinds?.includes(10050) && head)
+ socket.send(JSON.stringify(['EVENT', frame[1], JSON.parse(head)]));
+ if (filter.kinds?.includes(1059)) {
+ if (readMode === 'refused' || readMode === 'auth_required') {
+ socket.send(
+ JSON.stringify([
+ 'CLOSED',
+ frame[1],
+ readMode === 'auth_required'
+ ? 'auth-required: source fixture'
+ : 'blocked source fixture'
+ ])
+ );
+ return;
+ }
+ if (readMode === 'unknown') return;
+ const original = archived.get(filter.ids?.[0] ?? '');
+ if (original && readMode !== 'empty') {
+ const event: Record<string, unknown> =
+ readMode === 'metadata'
+ ? {
+ sig: original.sig,
+ content: original.content,
+ tags: original.tags,
+ created_at: original.created_at,
+ kind: original.kind,
+ pubkey: original.pubkey,
+ id: original.id,
+ observation: { fixture: true }
+ }
+ : { ...original };
+ if (readMode === 'wrong_id') event.id = 'f'.repeat(64);
+ if (readMode === 'wrong_sig') {
+ event.sig = '0'.repeat(128);
+ event.verified = true;
+ }
+ if (readMode === 'wrong_recipient')
+ event.tags = [['p', 'f'.repeat(64)]];
+ if (readMode === 'wrong_content')
+ event.content = String(event.content) + 'a';
+ if (readMode === 'oversized' || readMode === 'flood_bytes')
+ event.content = 'x'.repeat(
+ readMode === 'oversized' ? 40000 : 31000
+ );
+ if (readMode === 'flood_deliveries')
+ event.content = String(event.content) + 'a';
+ let wire = JSON.stringify(['EVENT', frame[1], event]);
+ if (readMode === 'sdk_duplicate')
+ wire = wire.replace('"kind":1059', '"kind":1059,"kind":1059');
+ if (readMode === 'sdk_numeric_alias')
+ wire = wire.replace('"kind":1059', '"kind":1.059e3');
+ for (let n = 0; n < (readMode.startsWith('flood_') ? 501 : 1); n++)
+ socket.send(wire);
+ }
+ }
+ socket.send(JSON.stringify(['EOSE', frame[1]]));
+ } else if (frame[0] === 'AUTH') {
+ socket.send(
+ JSON.stringify(['OK', (frame[1] as { id: string }).id, true, ''])
+ );
+ } else if (frame[0] === 'EVENT' && response !== 'unknown') {
+ archived.set(
+ (frame[1] as { id: string }).id,
+ frame[1] as Record<string, unknown>
+ );
+ socket.send(
+ JSON.stringify([
+ 'OK',
+ response === 'wrong'
+ ? 'f'.repeat(64)
+ : (frame[1] as { id: string }).id,
+ response !== 'refused' && response !== 'auth_required',
+ response === 'auth_required'
+ ? 'auth-required: source fixture'
+ : response === 'refused'
+ ? 'blocked: source fixture'
+ : ''
+ ])
+ );
+ }
+ });
+ });
+ const result = await build({
+ configFile: false,
+ logLevel: 'silent',
+ build: {
+ write: false,
+ minify: false,
+ lib: {
+ entry: fileURLToPath(
+ new URL('./harness/inbox-probe-nonce.ts', import.meta.url)
+ ),
+ name: 'nc',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(result) ? result[0] : result;
+ if (!('output' in output)) throw Error('compiled fixture');
+ const chunks = output.output.filter((x) => x.type === 'chunk');
+ expect(chunks).toHaveLength(1);
+ bundle = chunks[0].code;
+});
+test.afterAll(async () => {
+ for (const socket of sockets.clients) socket.terminate();
+ await new Promise<void>((resolve) => sockets.close(() => resolve()));
+ await server.close();
+});
+test.beforeEach(async ({ page }, testInfo) => {
+ await expect.poll(() => physical.size).toBe(0);
+ head = '';
+ readMode = 'exact';
+ archived.clear();
+ response = 'accepted';
+ auth = false;
+ peak = 0;
+ privatePeak = 0;
+ privateConnections.clear();
+ frames.length = 0;
+ await page.addInitScript(
+ ({ endpoint }) => {
+ const Native = window.WebSocket;
+ window.WebSocket = class extends Native {
+ constructor(url: string | URL, protocols?: string | string[]) {
+ const origin = new URL(String(url)).origin;
+ if (
+ ![
+ 'wss://discovery.example.org',
+ 'wss://inbox.example.org',
+ 'wss://peer.example.org',
+ 'wss://archive.example.org'
+ ].includes(origin)
+ )
+ throw Error('unapproved fixture origin');
+ super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols);
+ if (
+ origin === 'wss://inbox.example.org' &&
+ window.ncAdvanceOnSocket
+ ) {
+ if (window.ncAdvanceOnSocket === 'network')
+ window.ncNetworkClock!.advance(45001);
+ else window.ncAdvancePage!();
+ }
+ if (
+ window.ncInvalidateOnSocket &&
+ origin === 'wss://inbox.example.org'
+ )
+ window.nc.closeInboxAccessController(
+ window.ncFixture.controller()!
+ );
+ }
+ override close(code?: number, reason?: string) {
+ if (window.ncFailClose)
+ throw Error('actual controlled disposal failure');
+ if (window.ncDelayClose)
+ (window.ncHeldClose ??= []).push(() => super.close(code, reason));
+ else super.close(code, reason);
+ }
+ };
+ },
+ { endpoint }
+ );
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+ head = await page.evaluate(async (multi) => {
+ window.ncFixture = await window.nc.makeNonceFixture();
+ return window.ncFixture.preferenceWire(
+ multi
+ ? [
+ 'wss://inbox.example.org',
+ 'wss://peer.example.org',
+ 'wss://archive.example.org'
+ ]
+ : ['wss://inbox.example.org']
+ );
+ }, testInfo.title.includes('three-origin'));
+ await page.evaluate(async () => {
+ const f = window.ncFixture;
+ await f.capture();
+ if (
+ (await f.reserve()).status !== 'reserved' ||
+ (await f.prepare()) !== 'wrapped' ||
+ (await f.commitOriginal()).status !== 'prepared'
+ )
+ throw Error('genuine cold native original setup');
+ });
+});
+test.afterEach(async ({ page }) => {
+ if (!page.isClosed())
+ await page.evaluate(() => {
+ window.ncRestore?.();
+ window.ncFailClose = false;
+ window.ncDelayClose = false;
+ for (const release of window.ncHeldClose ?? []) release();
+ window.ncFixture.close();
+ });
+});
+function privateEvents() {
+ return frames.filter(
+ (x) => x.origin !== 'wss://discovery.example.org' && x.frame[0] === 'EVENT'
+ );
+}
+function privateReads() {
+ return frames.filter(
+ (x) => x.origin !== 'wss://discovery.example.org' && x.frame[0] === 'REQ'
+ );
+}
+
+async function publishOriginal(page: import('@playwright/test').Page) {
+ return page.evaluate(async () => {
+ const f = window.ncFixture,
+ result = await f.publish();
+ await f.append(result);
+ return result;
+ });
+}
+async function readOriginal(page: import('@playwright/test').Page) {
+ await publishOriginal(page);
+ expect(
+ await page.evaluate(async () => {
+ const f = window.ncFixture,
+ result = await f.read();
+ const saved = await f.appendRead(result);
+ return { read: result.status, saved: saved.status };
+ })
+ ).toEqual({ read: 'readback', saved: 'saved' });
+}
+test('cold genuine B2 readback verifies original nonce by guarded SDK without an earlier ordinary send, plaintext exposure, row growth or extra traffic', async ({
+ page
+}) => {
+ await readOriginal(page);
+ const observed = await page.evaluate(async () => {
+ const f = window.ncFixture,
+ rows = await f.stored(),
+ before = f.counts(),
+ first = f.nonceCapture()!,
+ second = f.nonceCapture();
+ const inert = f.counts();
+ const receiver = f.decryptCallback(0, (x) => x);
+ const result = await f.nonce(first),
+ after = f.counts(),
+ again = await f.nonce(first),
+ binding = f.proofBinding();
+ const copies = {
+ reader: await window.nc.readInboxProbeNonce({ ...first }),
+ proof: window.nc.inboxProbeNonceProofBinding(
+ { ...result.proof! },
+ f.repository,
+ f.session,
+ f.policy
+ ),
+ ordinary: window.nc.recoveredSelfEnvelopeSnapshot(
+ result.proof! as unknown as Parameters<
+ typeof window.nc.recoveredSelfEnvelopeSnapshot
+ >[0]
+ )
+ };
+ return {
+ same: first === second,
+ before,
+ inert,
+ after,
+ result,
+ again,
+ binding: binding && {
+ owner: binding.owner,
+ command: binding.command,
+ rumorHash: binding.rumorHash,
+ eventId: binding.eventId,
+ keys: Object.keys(binding)
+ },
+ sameProof: result.proof === again.proof,
+ receivers: receiver.receivers(),
+ rowsSame: JSON.stringify(rows) === JSON.stringify(await f.stored()),
+ copies,
+ readiness: window.nc.inboxAccessControllerSnapshot(f.controller()!)
+ ?.readiness
+ };
+ });
+ expect(observed.same).toBe(true);
+ expect(observed.inert).toEqual(observed.before);
+ expect(observed.result.status).toBe('nonce_verified');
+ expect(observed.again.status).toBe('nonce_verified');
+ expect(observed.sameProof).toBe(true);
+ expect(observed.after.decrypts - observed.before.decrypts).toBe(2);
+ expect(observed.after.keys - observed.before.keys).toBe(3);
+ expect(observed.receivers).toBe(2);
+ expect(observed.rowsSame).toBe(true);
+ expect(observed.binding?.keys).not.toContain('rumorWire');
+ expect(observed.binding?.keys).not.toContain('sealWire');
+ expect(observed.binding?.keys).not.toContain('nonce');
+ expect(observed.copies).toEqual({
+ reader: { status: 'invalid' },
+ proof: undefined,
+ ordinary: undefined
+ });
+ expect(observed.readiness).toBe('unavailable');
+ expect(privateEvents()).toHaveLength(1);
+ expect(privateReads()).toHaveLength(1);
+});
+for (const review of [
+ undefined,
+ true,
+ 'reviewed_self_decryption',
+ 'reviewed_inbox_probe_commit'
+])
+ test(`nonce capture refuses wrong explicit review ${String(review)} without effects`, async ({
+ page
+ }) => {
+ await readOriginal(page);
+ expect(
+ await page.evaluate((review) => {
+ const f = window.ncFixture,
+ before = f.counts();
+ const reader = window.nc.captureInboxProbeNonceReader(
+ f.repository,
+ f.identity,
+ f.session,
+ f.policy,
+ f.lastRead()!,
+ review
+ );
+ return {
+ captured: !!reader,
+ unchanged: JSON.stringify(before) === JSON.stringify(f.counts())
+ };
+ }, review)
+ ).toEqual({ captured: false, unchanged: true });
+ });
+for (const fault of [
+ 'copy',
+ 'archive',
+ 'foreign_repository',
+ 'foreign_session',
+ 'copied_policy',
+ 'wrong_identity',
+ 'ordinary_family'
+])
+ test(`nonce admission rejects ${fault} original association`, async ({
+ page
+ }) => {
+ await readOriginal(page);
+ expect(
+ await page.evaluate(async (fault) => {
+ const f = window.ncFixture,
+ before = f.counts();
+ let identity = f.identity,
+ session = f.session,
+ repository = f.repository,
+ policy = f.policy,
+ observation = f.lastRead()!;
+ if (fault === 'copy') observation = { ...observation };
+ if (fault === 'archive')
+ observation = f.last() as unknown as typeof observation;
+ if (fault === 'foreign_repository') repository = f.foreignRepository();
+ if (fault === 'foreign_session') session = await f.foreignSession();
+ if (fault === 'copied_policy') policy = f.copiedPolicy();
+ if (fault === 'wrong_identity')
+ identity = window.nc.createIdentitySession();
+ if (fault === 'ordinary_family')
+ observation = {
+ status: 'readback',
+ eventId: f.snapshot()!.record.self!.eventId
+ };
+ const baseline = f.counts(),
+ reader = window.nc.captureInboxProbeNonceReader(
+ repository,
+ identity,
+ session,
+ policy,
+ observation,
+ 'reviewed_inbox_probe_nonce_decryption'
+ );
+ return {
+ captured: !!reader,
+ unchanged: JSON.stringify(baseline) === JSON.stringify(f.counts()),
+ initial: !!before
+ };
+ }, fault)
+ ).toEqual({ captured: false, unchanged: true, initial: true });
+ });
+for (const fault of [
+ 'removed',
+ 'alias',
+ 'corrupt',
+ 'handwritten_fact',
+ 'corrupt_tail'
+])
+ test(`nonce initial native custody rejects ${fault} before SDK`, async ({
+ page
+ }) => {
+ await readOriginal(page);
+ const result = await page.evaluate(async (fault) => {
+ const f = window.ncFixture,
+ reader = f.nonceCapture()!,
+ before = f.counts(),
+ row = (await f.stored())[0];
+ if (fault === 'removed') await f.removeOriginal();
+ else if (fault === 'alias')
+ await f.inject([{ ...row, wire: row.wire + '\n' }]);
+ else if (fault === 'corrupt') await f.inject([{ ...row, wire: '{}' }]);
+ else if (fault === 'handwritten_fact') await f.changedNativeFact();
+ else
+ await f.inject([
+ { owner: f.owner, id: crypto.randomUUID(), wire: '{}' }
+ ]);
+ const result = await f.nonce(reader);
+ return {
+ status: result.status,
+ unchanged: JSON.stringify(before) === JSON.stringify(f.counts()),
+ proof: !!f.proofBinding()
+ };
+ }, fault);
+ expect(result.status).not.toBe('nonce_verified');
+ expect(result.unchanged).toBe(true);
+ expect(result.proof).toBe(false);
+ });
+for (const mode of [
+ 'wrong_key',
+ 'refuse_decrypt',
+ 'wrong_decrypt',
+ 'stop_decrypt_getter'
+] as const)
+ test(`actual provider ${mode} refuses nonce proof`, async ({ page }) => {
+ await readOriginal(page);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.ncFixture,
+ reader = f.nonceCapture()!;
+ f.mode(mode);
+ const result = await f.nonce(reader);
+ return { status: result.status, proof: !!f.proofBinding() };
+ }, mode);
+ expect(result.status).not.toBe('nonce_verified');
+ expect(result.proof).toBe(false);
+ expect(privateEvents()).toHaveLength(1);
+ expect(privateReads()).toHaveLength(1);
+ });
+for (const fault of [
+ 'outer_huge',
+ 'seal_signature',
+ 'seal_tags',
+ 'seal_kind',
+ 'rumor_owner',
+ 'rumor_time',
+ 'rumor_hash',
+ 'rumor_body',
+ 'rumor_huge',
+ 'rumor_serialization'
+])
+ test(`actual decrypted ${fault} cannot mint a nonce proof`, async ({
+ page
+ }) => {
+ await readOriginal(page);
+ const result = await page.evaluate(async (fault) => {
+ const f = window.ncFixture,
+ outer = fault.startsWith('outer') || fault.startsWith('seal');
+ f.decryptCallback(outer ? 1 : 2, async (wire) => {
+ if (fault.endsWith('huge')) return 'x'.repeat(outer ? 16385 : 8193);
+ if (fault === 'rumor_serialization') return wire + '\n';
+ if (fault === 'seal_tags')
+ return f.signSeal(wire, { tags: [['p', f.owner]] });
+ if (fault === 'seal_kind') return f.signSeal(wire, { kind: 14 });
+ const parsed = JSON.parse(wire) as Record<string, unknown>;
+ if (fault === 'seal_signature') {
+ parsed.sig = '0'.repeat(128);
+ parsed.verified = true;
+ }
+ if (fault === 'rumor_owner') parsed.pubkey = 'f'.repeat(64);
+ if (fault === 'rumor_time')
+ parsed.created_at = Number(parsed.created_at) + 1;
+ if (fault === 'rumor_hash') parsed.id = 'f'.repeat(64);
+ if (fault === 'rumor_body')
+ parsed.content =
+ 'Harvestcircle private inbox access check v1: ' + '0'.repeat(64);
+ return JSON.stringify(parsed);
+ });
+ const result = await f.nonce();
+ return { status: result.status, proof: !!f.proofBinding() };
+ }, fault);
+ expect(result.status).toBe('mismatch');
+ expect(result.proof).toBe(false);
+ });
+for (const stage of [1, 2, 3])
+ for (const fault of ['head', 'controller', 'session', 'native'])
+ test(`actual key ${stage} ${fault} churn prevents nonce proof`, async ({
+ page
+ }) => {
+ await readOriginal(page);
+ const result = await page.evaluate(
+ async ({ stage, fault }) => {
+ const f = window.ncFixture,
+ reader = f.nonceCapture()!;
+ f.keyCallback(stage, async () => {
+ if (fault === 'head') f.churnHead();
+ else if (fault === 'controller')
+ window.nc.closeInboxAccessController(f.controller()!);
+ else if (fault === 'session') f.closeSession();
+ else await f.changedNativeFact();
+ });
+ const result = await f.nonce(reader);
+ return { status: result.status, proof: !!f.proofBinding() };
+ },
+ { stage, fault }
+ );
+ expect(result.status).not.toBe('nonce_verified');
+ expect(result.proof).toBe(false);
+ });
+test('actual cipher getter currentness loss cannot call captured decrypt method', async ({
+ page
+}) => {
+ await readOriginal(page);
+ const result = await page.evaluate(async () => {
+ const f = window.ncFixture,
+ reader = f.nonceCapture()!,
+ before = f.counts();
+ f.cipherGetter(() => f.churnHead());
+ const result = await f.nonce(reader);
+ return {
+ status: result.status,
+ calls: f.counts().decrypts - before.decrypts,
+ proof: !!f.proofBinding(),
+ identityCurrent: !!window.nc
+ .identityMessagingOwnership(f.identity)
+ ?.current(),
+ privateCurrent: !!window.nc.privateSessionOwnership(f.session)?.current()
+ };
+ });
+ expect(result).toEqual({
+ status: 'stopped',
+ calls: 0,
+ proof: false,
+ identityCurrent: true,
+ privateCurrent: true
+ });
+});
+for (const stop of ['stop', 'expire', 'head', 'controller', 'session'])
+ test(`pending real SDK decrypt ${stop} retains original slot and refuses late proof`, async ({
+ page
+ }) => {
+ await readOriginal(page);
+ await page.evaluate(() => {
+ const f = window.ncFixture;
+ f.mode('hold_decrypt');
+ window.ncNoncePending = f.nonce();
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.ncFixture.waiting()))
+ .toBe('decrypt');
+ const pending = await page.evaluate(async (stop) => {
+ const f = window.ncFixture,
+ reader = f.nonceReader()!;
+ if (stop === 'stop') window.nc.stopInboxProbeNonceReader(reader);
+ else if (stop === 'expire')
+ window.nc.expireInboxProbeNonceReaderWait(reader);
+ else if (stop === 'head') f.churnHead();
+ else if (stop === 'controller')
+ window.nc.closeInboxAccessController(f.controller()!);
+ else f.closeSession();
+ const slot = window.nc.browserExtensionScheduler()!,
+ before = window.nc.extensionSchedulerSnapshot(slot),
+ another = await window.nc.runExtensionAction(
+ slot,
+ { owner: f.owner, session: Symbol(), operation: Symbol() },
+ () => true,
+ () => Promise.resolve('bad')
+ );
+ const proof = !!f.proofBinding();
+ f.settle();
+ return { before, another, proof };
+ }, stop);
+ expect(pending.before).toMatchObject({
+ state: 'active',
+ pending: 'decrypt'
+ });
+ expect(pending.another).toEqual({ status: 'busy' });
+ expect(pending.proof).toBe(false);
+ expect(
+ await page.evaluate(async () => {
+ await window.ncNoncePending;
+ return {
+ proof: !!window.ncFixture.proofBinding(),
+ slot: window.nc.extensionSchedulerSnapshot(
+ window.nc.browserExtensionScheduler()!
+ )
+ };
+ })
+ ).toEqual({ proof: false, slot: { state: 'idle' } });
+ });
+for (const stop of [
+ 'stop',
+ 'expire',
+ 'head',
+ 'controller',
+ 'session',
+ 'identity'
+])
+ test(`genuine memory proof revokes on ${stop} without persisted nonce label or cleanup`, async ({
+ page
+ }) => {
+ await readOriginal(page);
+ const result = await page.evaluate(async (stop) => {
+ const f = window.ncFixture;
+ const rows = await f.stored();
+ await f.nonce();
+ const before = !!f.proofBinding();
+ if (stop === 'stop')
+ window.nc.stopInboxProbeNonceReader(f.nonceReader()!);
+ else if (stop === 'expire')
+ window.nc.expireInboxProbeNonceReaderWait(f.nonceReader()!);
+ else if (stop === 'head') f.churnHead();
+ else if (stop === 'controller')
+ window.nc.closeInboxAccessController(f.controller()!);
+ else if (stop === 'identity') window.nc.disconnectIdentity(f.identity);
+ else f.closeSession();
+ return {
+ before,
+ after: !!f.proofBinding(),
+ retained: JSON.stringify(rows) === JSON.stringify(await f.stored())
+ };
+ }, stop);
+ expect(result).toEqual({ before: true, after: false, retained: true });
+ });
+test('parallel and callback reentry share original observation reader and never start another SDK action', async ({
+ page
+}) => {
+ await readOriginal(page);
+ await page.evaluate(() => {
+ const f = window.ncFixture;
+ const original = f.nonceCapture()!;
+ f.keyCallback(1, () => {
+ if (f.nonceCapture() !== original)
+ throw Error('reentrant reader changed');
+ window.ncNonceOther = window.nc.readInboxProbeNonce(original);
+ });
+ f.mode('hold_decrypt');
+ window.ncNoncePending = f.nonce(original);
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.ncFixture.waiting()))
+ .toBe('decrypt');
+ expect(
+ await page.evaluate(async () => {
+ const f = window.ncFixture,
+ other = await window.ncNonceOther,
+ parallel = await window.nc.readInboxProbeNonce(f.nonceReader()!);
+ f.mode('normal');
+ f.settle();
+ return { other, parallel };
+ })
+ ).toEqual({ other: { status: 'busy' }, parallel: { status: 'busy' } });
+ expect(
+ await page.evaluate(async () => {
+ const result = (await window.ncNoncePending) as { status: string };
+ return result.status;
+ })
+ ).toBe('nonce_verified');
+});
+
+test('genuine ordinary and nonce reader brands cannot cross and ordinary probe-row reading remains invalid_scope', async ({
+ page
+}) => {
+ await readOriginal(page);
+ const result = await page.evaluate(async () => {
+ const f = window.ncFixture,
+ nonce = f.nonceCapture()!,
+ ordinary = window.nc.captureSelfRecoveryReader(
+ f.repository,
+ f.identity,
+ f.snapshot()!.record.id,
+ 'reviewed_self_decryption'
+ )!;
+ const before = f.counts();
+ const nonceFromOrdinary = await window.nc.readInboxProbeNonce(
+ ordinary as unknown as Parameters<
+ typeof window.nc.readInboxProbeNonce
+ >[0]
+ ),
+ ordinaryFromNonce = await window.nc.readSelfRecoveryEnvelope(
+ nonce as unknown as Parameters<
+ typeof window.nc.readSelfRecoveryEnvelope
+ >[0]
+ ),
+ originalOrdinary = await window.nc.readSelfRecoveryEnvelope(ordinary);
+ return {
+ genuine: !!ordinary && !!nonce,
+ nonceFromOrdinary,
+ ordinaryFromNonce,
+ originalOrdinary,
+ unchanged: JSON.stringify(before) === JSON.stringify(f.counts())
+ };
+ });
+ expect(result).toEqual({
+ genuine: true,
+ nonceFromOrdinary: { status: 'invalid' },
+ ordinaryFromNonce: { status: 'invalid' },
+ originalOrdinary: { status: 'invalid_scope' },
+ unchanged: true
+ });
+});
+test('forged read result cannot retry cleanup of a genuine closed private session', async ({
+ page
+}) => {
+ await readOriginal(page);
+ expect(
+ await page.evaluate(() => {
+ const f = window.ncFixture;
+ let retries = 0;
+ const off = window.nc.subscribePrivateSessionClose(f.session, () => {
+ retries++;
+ throw Error('controlled retained original cleanup');
+ });
+ f.closeSession();
+ const before = retries;
+ const reader = window.nc.captureInboxProbeNonceReader(
+ f.repository,
+ f.identity,
+ f.session,
+ f.policy,
+ { status: 'readback' },
+ 'reviewed_inbox_probe_nonce_decryption'
+ );
+ const after = retries,
+ cleanup = window.nc.privateSessionCleanupRequired(f.session);
+ off();
+ return { captured: !!reader, unchanged: before === after, cleanup };
+ })
+ ).toEqual({ captured: false, unchanged: true, cleanup: true });
+});
+for (const fault of [
+ 'provider',
+ 'key_method',
+ 'cipher',
+ 'decrypt_method',
+ 'throw_cipher',
+ 'cipher_version'
+])
+ test(`missing or invalid actual ${fault} never authorizes nonce proof`, async ({
+ page
+ }) => {
+ await readOriginal(page);
+ const result = await page.evaluate(async (fault) => {
+ const f = window.ncFixture,
+ reader = f.nonceCapture()!,
+ provider = Reflect.get(window, 'nostr') as {
+ getPublicKey(): Promise<string>;
+ nip44: { decrypt(target: string, content: string): Promise<string> };
+ },
+ descriptor = Object.getOwnPropertyDescriptor(window, 'nostr')!;
+ const cipher = provider.nip44,
+ cipherDescriptor = Object.getOwnPropertyDescriptor(provider, 'nip44')!,
+ keyDescriptor = Object.getOwnPropertyDescriptor(
+ provider,
+ 'getPublicKey'
+ )!,
+ decryptDescriptor = Object.getOwnPropertyDescriptor(cipher, 'decrypt')!;
+ try {
+ if (fault === 'provider')
+ Object.defineProperty(window, 'nostr', {
+ configurable: true,
+ value: undefined
+ });
+ else if (fault === 'key_method')
+ Object.defineProperty(provider, 'getPublicKey', {
+ configurable: true,
+ value: undefined
+ });
+ else if (fault === 'cipher')
+ Object.defineProperty(provider, 'nip44', {
+ configurable: true,
+ value: undefined
+ });
+ else if (fault === 'decrypt_method')
+ Object.defineProperty(cipher, 'decrypt', {
+ configurable: true,
+ value: undefined
+ });
+ else if (fault === 'throw_cipher')
+ Object.defineProperty(provider, 'nip44', {
+ configurable: true,
+ get() {
+ throw Error('controlled actual capability getter');
+ }
+ });
+ else
+ f.decryptCallback(1, (wire) =>
+ f.signSeal(wire, { content: 'not NIP44v2' })
+ );
+ const result = await f.nonce(reader);
+ return { status: result.status, proof: !!f.proofBinding() };
+ } finally {
+ Object.defineProperty(window, 'nostr', descriptor);
+ Object.defineProperty(provider, 'nip44', cipherDescriptor);
+ Object.defineProperty(provider, 'getPublicKey', keyDescriptor);
+ Object.defineProperty(cipher, 'decrypt', decryptDescriptor);
+ }
+ }, fault);
+ expect(result.status).not.toBe('nonce_verified');
+ expect(result.proof).toBe(false);
+ });
+test('same-owner replacement genuine identity has no original private session nonce admission', async ({
+ page
+}) => {
+ await readOriginal(page);
+ expect(
+ await page.evaluate(async () => {
+ const f = window.ncFixture,
+ replacement = window.nc.createIdentitySession();
+ await window.nc.connectIdentity(replacement);
+ await window.nc.probeIdentityMessaging(replacement, 'reviewed_self_copy');
+ const sameOwner =
+ window.nc.identityMessagingOwnership(replacement)?.owner === f.owner,
+ before = f.counts();
+ const reader = window.nc.captureInboxProbeNonceReader(
+ f.repository,
+ replacement,
+ f.session,
+ f.policy,
+ f.lastRead()!,
+ 'reviewed_inbox_probe_nonce_decryption'
+ );
+ const unchanged = JSON.stringify(before) === JSON.stringify(f.counts());
+ window.nc.disconnectIdentity(replacement);
+ return { captured: !!reader, sameOwner, unchanged };
+ })
+ ).toEqual({ captured: false, sameOwner: true, unchanged: true });
+});
+for (const hit of [1, 2])
+ test(`actual native readonly abort ${hit} refuses nonce proof`, async ({
+ page
+ }) => {
+ await readOriginal(page);
+ const result = await page.evaluate(async (hit) => {
+ const f = window.ncFixture,
+ reader = f.nonceCapture()!,
+ original = Object.getOwnPropertyDescriptor(
+ IDBDatabase.prototype,
+ 'transaction'
+ )!.value as IDBDatabase['transaction'];
+ let reads = 0,
+ aborted = 0;
+ IDBDatabase.prototype.transaction = function (
+ ...args: Parameters<IDBDatabase['transaction']>
+ ) {
+ const tx = original.apply(this, args);
+ if (
+ args[1] === 'readonly' &&
+ tx.objectStoreNames.contains('private_sends') &&
+ ++reads === hit
+ ) {
+ aborted++;
+ queueMicrotask(() => tx.abort());
+ }
+ return tx;
+ };
+ try {
+ const result = await f.nonce(reader);
+ return { status: result.status, proof: !!f.proofBinding(), aborted };
+ } finally {
+ IDBDatabase.prototype.transaction = original;
+ }
+ }, hit);
+ expect(result.status).not.toBe('nonce_verified');
+ expect(result.proof).toBe(false);
+ expect(result.aborted).toBe(1);
+ });
+test('actual occupied owner lock prevents SDK nonce work', async ({ page }) => {
+ await readOriginal(page);
+ expect(
+ await page.evaluate(async () => {
+ const f = window.ncFixture,
+ reader = f.nonceCapture()!;
+ let entered: (() => void) | undefined, release: (() => void) | undefined;
+ const ready = new Promise<void>((resolve) => {
+ entered = resolve;
+ });
+ const held = navigator.locks.request(
+ 'harvestcircle:owner:' + f.owner,
+ async () => {
+ entered?.();
+ await new Promise<void>((resolve) => {
+ release = resolve;
+ });
+ }
+ );
+ await ready;
+ const before = f.counts();
+ try {
+ const result = await f.nonce(reader);
+ return {
+ status: result.status,
+ unchanged: JSON.stringify(before) === JSON.stringify(f.counts())
+ };
+ } finally {
+ release?.();
+ await held;
+ }
+ })
+ ).toEqual({ status: 'busy', unchanged: true });
+});
+for (const fault of ['wrong', 'denied'])
+ test(`actual ${fault} key refuses before any cipher getter acquisition`, async ({
+ page
+ }) => {
+ await readOriginal(page);
+ expect(
+ await page.evaluate(async (fault) => {
+ const f = window.ncFixture,
+ reader = f.nonceCapture()!;
+ let getters = 0;
+ f.cipherGetter(() => {
+ getters++;
+ });
+ if (fault === 'wrong') f.mode('wrong_key');
+ else
+ f.keyCallback(1, () => {
+ throw Error('actual controlled key refusal');
+ });
+ const before = f.counts(),
+ result = await f.nonce(reader);
+ return {
+ status: result.status,
+ getters,
+ decrypts: f.counts().decrypts - before.decrypts,
+ identityCurrent: !!window.nc
+ .identityMessagingOwnership(f.identity)
+ ?.current()
+ };
+ }, fault)
+ ).toEqual({
+ status: 'stopped',
+ getters: 0,
+ decrypts: 0,
+ identityCurrent: false
+ });
+ });
diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs
@@ -1976,6 +1976,8 @@ import { auditOutput } from '../../tools/check-output.mjs';
'src/lib/nostr/giftwrap-builder.ts',
'src/lib/config/inbox-operators.ts',
'src/lib/persistence/private-sends.ts',
+ // CR008-S4C1: both current admissions bind the actual shared guarded
+ // self reader and distinct original-observation nonce proof owner.
'src/lib/nostr/self-recovery-reader.ts',
'src/lib/config/operation-flags.ts',
'src/lib/nostr/private-pool.ts',
diff --git a/web/tests/unit/inbox-probe-nonce.test.ts b/web/tests/unit/inbox-probe-nonce.test.ts
@@ -0,0 +1,83 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import type { IdentitySession } from '../../src/lib/runtime/identity-session.ts';
+import type { PrivateSession } from '../../src/lib/runtime/private-session.ts';
+import type { PrivateStorageRepository } from '../../src/lib/persistence/private-storage.ts';
+import type { RelayPolicy } from '../../src/lib/config/relays.ts';
+import type { InboxProbeReadbackAttemptResult } from '../../src/lib/nostr/private-pool.ts';
+import type {
+ InboxProbeNonceReader,
+ InboxProbeNonceProof,
+ SelfRecoveryReader,
+ RecoveredSelfEnvelope
+} from '../../src/lib/nostr/self-recovery-reader.ts';
+afterEach(() => vi.unstubAllGlobals());
+for (const browser of [false, true])
+ it(`cold ${browser ? 'browser-shaped' : 'SSR'} nonce admission rejects forged families before provider, storage or socket effects`, async () => {
+ vi.resetModules();
+ let effects = 0;
+ const trap = () => {
+ effects++;
+ throw Error('forged effect');
+ };
+ if (browser) {
+ vi.stubGlobal('window', {
+ get nostr() {
+ return trap();
+ }
+ });
+ vi.stubGlobal('navigator', {
+ get locks() {
+ return trap();
+ }
+ });
+ vi.stubGlobal('WebSocket', trap);
+ vi.stubGlobal('indexedDB', { open: trap });
+ }
+ const m = await import('../../src/lib/nostr/self-recovery-reader.ts');
+ const repository = {} as PrivateStorageRepository,
+ identity = {} as IdentitySession,
+ session = {} as PrivateSession,
+ policy = {} as RelayPolicy;
+ for (const fake of [
+ null,
+ undefined,
+ 0,
+ false,
+ '',
+ Symbol(),
+ {},
+ { status: 'readback', nonce_verified: true, current: () => true },
+ { status: 'nonce_verified', proof: {} }
+ ]) {
+ expect(
+ m.captureInboxProbeNonceReader(
+ repository,
+ identity,
+ session,
+ policy,
+ fake as InboxProbeReadbackAttemptResult,
+ 'reviewed_inbox_probe_nonce_decryption'
+ )
+ ).toBeUndefined();
+ expect(
+ await m.readInboxProbeNonce(fake as InboxProbeNonceReader)
+ ).toEqual({ status: 'invalid' });
+ expect(
+ m.inboxProbeNonceProofBinding(
+ fake as InboxProbeNonceProof,
+ repository,
+ session,
+ policy
+ )
+ ).toBeUndefined();
+ m.stopInboxProbeNonceReader(fake as InboxProbeNonceReader);
+ m.expireInboxProbeNonceReaderWait(fake as InboxProbeNonceReader);
+ expect(
+ await m.readSelfRecoveryEnvelope(fake as SelfRecoveryReader)
+ ).toEqual({ status: 'invalid' });
+ expect(
+ m.recoveredSelfEnvelopeSnapshot(fake as RecoveredSelfEnvelope)
+ ).toBeUndefined();
+ }
+ expect(effects).toBe(0);
+ });
diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs
@@ -317,7 +317,7 @@ async function operationalFlagsAdmission(web) {
'src/lib/messaging/inbox-setup-operation.ts':
'245c6ce88b146dc731e7ace4f16dc9b5002a87a997f5568e4811b0c4a2daf035',
'src/lib/nostr/self-recovery-reader.ts':
- 'b15be31d13499b6e397f8b8dc691076e2b41b4157bf62013e5105cdd03875fa6',
+ '806230d8082a48b9c2117a16060aff50312be270348d7b8c5b93d6d6368d31a1',
'src/lib/nostr/private-publisher.ts':
'2f939dda3504b760dbf3758632cda6ce38d3e16c6d142b814e40a0e295a77d90',
'src/lib/nostr/private-pool.ts':
@@ -595,7 +595,7 @@ async function privacyDataAdmission(web) {
'src/lib/messaging/inbox-list.ts':
'9cc82877bfa8dbb2a7fa41bceb842793349416271f19569f49fdd5cfc1de07e5',
'src/lib/nostr/self-recovery-reader.ts':
- 'b15be31d13499b6e397f8b8dc691076e2b41b4157bf62013e5105cdd03875fa6',
+ '806230d8082a48b9c2117a16060aff50312be270348d7b8c5b93d6d6368d31a1',
'src/lib/nostr/private-publisher.ts':
'2f939dda3504b760dbf3758632cda6ce38d3e16c6d142b814e40a0e295a77d90',
'src/lib/nostr/private-pool.ts':