commit 90762e7b75cff35a72ece3dc3c922b3e3421101c
parent 2904a994d5ba6199c444586089720244c8d1eed8
Author: triesap <tyson@radroots.org>
Date: Fri, 9 Oct 2026 05:22:03 +0000
messages: validate nested received seals and rumor identity (HCP-091)
Diffstat:
4 files changed, 1089 insertions(+), 0 deletions(-)
diff --git a/web/src/lib/nostr/unwrap-admission.ts b/web/src/lib/nostr/unwrap-admission.ts
@@ -0,0 +1,469 @@
+import { ExtensionSigner } from 'applesauce-signers';
+import { getEventHash, type UnsignedEvent } from 'applesauce-core/helpers';
+import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts';
+import { canonicalPublicKey } from '../contracts/public-key.ts';
+import { exactLocalFields } from '../contracts/local-records.ts';
+import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
+import {
+ messageFromWireParts,
+ messageToWireParts
+} from '../contracts/message-v1/index.ts';
+import {
+ identityMessagingOwnership,
+ subscribeIdentityInvalidation,
+ disconnectIdentity,
+ type IdentitySession
+} from '../runtime/identity-session.ts';
+import {
+ loadPrivateRecord,
+ type PrivateStorageRepository,
+ type PrivateStorageFailure
+} from '../persistence/private-storage.ts';
+import {
+ privateRecordSnapshot,
+ privateRecordWire
+} from '../persistence/private-records.ts';
+import { safeUnsignedInteger } from './envelope-bounds.ts';
+import {
+ verifyEnvelope,
+ verifiedEnvelopeSnapshot
+} from './verified-envelope.ts';
+import { sealCiphertextV2 } from './seal-template.ts';
+import {
+ browserExtensionScheduler,
+ runExtensionAction,
+ callExtension,
+ stopExtensionAction,
+ markExtensionWaitExpired,
+ type ExtensionAction
+} from './extension-scheduler.ts';
+
+const unsignedFields = [
+ 'id',
+ 'pubkey',
+ 'created_at',
+ 'kind',
+ 'tags',
+ 'content'
+];
+const signedFields = [...unsignedFields, 'sig'];
+// Syntax-only duplicate detection precedes ordinary JSON semantics. Escaped
+// field aliases count as the same key; harmless whitespace stays supported.
+function uniqueJSONFields(raw: string): boolean {
+ type Frame = {
+ array: boolean;
+ key: boolean;
+ parent: Frame | undefined;
+ accept: (name: string) => boolean;
+ };
+ function frame(parent: Frame | undefined, array: boolean): Frame {
+ const names = new Set<string>();
+ return {
+ parent,
+ array,
+ key: !array,
+ accept: (name: string) => {
+ if (names.has(name)) return false;
+ names.add(name);
+ return true;
+ }
+ };
+ }
+ let current: Frame | undefined;
+ try {
+ for (let index = 0; index < raw.length; index++) {
+ const character = raw[index];
+ if (character === '"') {
+ let end = index + 1;
+ while (end < raw.length) {
+ if (raw[end] === '\\') {
+ end += 2;
+ continue;
+ }
+ if (raw[end] === '"') break;
+ end++;
+ }
+ if (end >= raw.length) return false;
+ if (current && !current.array && current.key) {
+ const name: unknown = JSON.parse(raw.slice(index, end + 1));
+ if (typeof name !== 'string' || !current.accept(name)) return false;
+ current = {
+ parent: current.parent,
+ array: current.array,
+ accept: current.accept,
+ key: false
+ };
+ }
+ index = end;
+ } else if (character === '{' || character === '[')
+ current = frame(current, character === '[');
+ else if (character === '}' || character === ']') {
+ if (!current) return false;
+ current = current.parent;
+ } else if (character === ',' && current && !current.array)
+ current = {
+ parent: current.parent,
+ array: current.array,
+ accept: current.accept,
+ key: true
+ };
+ }
+ return current === undefined;
+ } catch {
+ return false;
+ }
+}
+function layer(raw: unknown, bytes: number): unknown {
+ if (
+ typeof raw !== 'string' ||
+ !boundedUtf8(raw, bytes) ||
+ !uniqueJSONFields(raw)
+ )
+ return undefined;
+ try {
+ let invalid = false;
+ const parsed: unknown = JSON.parse(
+ raw,
+ function (key: string, value: unknown, context?: { source?: string }) {
+ if (
+ !key.isWellFormed() ||
+ (typeof value === 'string' && !value.isWellFormed())
+ )
+ invalid = true;
+ if (
+ typeof value === 'number' &&
+ (!Number.isFinite(value) ||
+ ((key === 'kind' || key === 'created_at') &&
+ (context?.source === undefined ||
+ !/^[0-9]+$/u.test(context.source))))
+ )
+ invalid = true;
+ return value;
+ }
+ );
+ return invalid ? undefined : parsed;
+ } catch {
+ return undefined;
+ }
+}
+function outerLayer(raw: unknown, owner: string) {
+ const parsed = layer(raw, PRIVATE_TRANSPORT_BUDGETS.envelopeBytes);
+ if (
+ !exactLocalFields(parsed, signedFields) ||
+ parsed.kind !== 1059 ||
+ JSON.stringify(parsed.tags) !== JSON.stringify([['p', owner]]) ||
+ !sealCiphertextV2(parsed.content)
+ )
+ return undefined;
+ const verified = verifyEnvelope(raw);
+ return verified.ok ? verifiedEnvelopeSnapshot(verified.value) : undefined;
+}
+function sealLayer(raw: unknown) {
+ const parsed = layer(raw, PRIVATE_TRANSPORT_BUDGETS.sealBytes);
+ if (
+ !exactLocalFields(parsed, signedFields) ||
+ parsed.kind !== 13 ||
+ !Array.isArray(parsed.tags) ||
+ parsed.tags.length !== 0 ||
+ !sealCiphertextV2(parsed.content)
+ )
+ return undefined;
+ const verified = verifyEnvelope(raw);
+ return verified.ok ? verifiedEnvelopeSnapshot(verified.value) : undefined;
+}
+function rumorLayer(
+ raw: unknown,
+ sender: string
+): Readonly<UnsignedEvent & { id: string }> | undefined {
+ const parsed = layer(raw, PRIVATE_TRANSPORT_BUDGETS.rumorBytes);
+ if (
+ !exactLocalFields(parsed, unsignedFields) ||
+ parsed.kind !== 14 ||
+ parsed.pubkey !== sender ||
+ canonicalPublicKey(parsed.pubkey) !== sender ||
+ safeUnsignedInteger(parsed.created_at) === undefined ||
+ typeof parsed.id !== 'string' ||
+ !/^[0-9a-f]{64}$/u.test(parsed.id)
+ )
+ return undefined;
+ const parts = { kind: 14, tags: parsed.tags, content: parsed.content };
+ const decoded = messageFromWireParts(JSON.stringify(parts));
+ if (
+ !decoded ||
+ decoded.recipients.length !== 1 ||
+ decoded.recipients[0].public_key === sender
+ )
+ return undefined;
+ const canonical = messageToWireParts(JSON.stringify(decoded));
+ if (!canonical || JSON.stringify(canonical) !== JSON.stringify(parts))
+ return undefined;
+ const template: UnsignedEvent = {
+ pubkey: sender,
+ kind: 14,
+ created_at: parsed.created_at as number,
+ tags: canonical.tags.map((row) => [...row]),
+ content: canonical.content
+ };
+ return getEventHash(template) === parsed.id
+ ? { id: parsed.id, ...template }
+ : undefined;
+}
+// Detached inspection only: supplied plaintext cannot prove ciphertext
+// correspondence. Only the scoped actual SDK issuer below mints nested custody.
+// Owner room membership and inbound/archive role are a separate admission.
+export function verifyReceivedLayerData(
+ outerRaw: unknown,
+ sealRaw: unknown,
+ rumorRaw: unknown,
+ expectedOwner: unknown
+): boolean {
+ const owner = canonicalPublicKey(expectedOwner);
+ if (!owner) return false;
+ try {
+ const outer = outerLayer(outerRaw, owner),
+ seal = sealLayer(sealRaw);
+ return !!outer && !!seal && !!rumorLayer(rumorRaw, seal.pubkey);
+ } catch {
+ return false;
+ }
+}
+
+declare const readerBrand: unique symbol;
+declare const nestedBrand: unique symbol;
+export type ReceivedUnwrap = Readonly<{ [readerBrand]: true }>;
+export type ReceivedNestedEnvelope = Readonly<{ [nestedBrand]: true }>;
+type Snapshot = Readonly<{
+ owner: string;
+ outerId: string;
+ outerWire: string;
+ sealWire: string;
+ rumorWire: string;
+}>;
+export type ReceivedUnwrapResult =
+ | Readonly<{ status: 'authenticated'; envelope: ReceivedNestedEnvelope }>
+ | Readonly<{
+ status:
+ | PrivateStorageFailure
+ | 'invalid'
+ | 'stopped'
+ | 'busy'
+ | 'refused'
+ | 'mismatch'
+ | 'lost_evidence';
+ }>;
+type Reader = {
+ run(): Promise<ReceivedUnwrapResult>;
+ stop(expired: boolean): void;
+};
+const readers = new WeakMap<ReceivedUnwrap, Reader>();
+const nested = new WeakMap<
+ ReceivedNestedEnvelope,
+ { snapshot: Snapshot; current(): boolean }
+>();
+// No common unwrap helper/cache or caller event objects are consulted. Original
+// owner storage finishes each IDB transaction before serialized SDK work begins.
+export function captureReceivedUnwrap(
+ repository: PrivateStorageRepository,
+ session: IdentitySession,
+ eventId: unknown,
+ review: unknown
+): ReceivedUnwrap | undefined {
+ if (
+ typeof window === 'undefined' ||
+ review !== 'reviewed_inbox_unlock' ||
+ typeof eventId !== 'string' ||
+ !/^[0-9a-f]{64}$/u.test(eventId)
+ )
+ return undefined;
+ const captured = identityMessagingOwnership(session);
+ if (!captured?.current()) return undefined;
+ const ownership = captured,
+ id = eventId;
+ let stopped = false,
+ started = false,
+ active: ExtensionAction | undefined,
+ proof: ReceivedNestedEnvelope | undefined,
+ unsubscribe = () => {};
+ const current = () => !stopped && ownership.current();
+ function stop(expired: boolean) {
+ stopped = true;
+ if (active) {
+ if (expired) markExtensionWaitExpired(active);
+ else stopExtensionAction(active);
+ }
+ if (proof) nested.delete(proof);
+ proof = undefined;
+ unsubscribe();
+ unsubscribe = () => {};
+ }
+ function port() {
+ try {
+ if (!current()) return undefined;
+ const cipher = new ExtensionSigner().nip44;
+ if (!cipher || !current() || typeof cipher.decrypt !== 'function')
+ return undefined;
+ const decrypt = cipher.decrypt.bind(cipher);
+ return current() ? { decrypt } : undefined;
+ } catch {
+ return undefined;
+ }
+ }
+ async function fresh(action: ExtensionAction) {
+ if (!current()) return false;
+ const result = await callExtension(action, 'key', () =>
+ new ExtensionSigner().getPublicKey()
+ );
+ if (!current()) return false;
+ if (
+ result.status !== 'settled' ||
+ !result.current ||
+ result.value !== ownership.owner ||
+ !port()
+ ) {
+ disconnectIdentity(session);
+ return false;
+ }
+ return current();
+ }
+ async function run(): Promise<ReceivedUnwrapResult> {
+ if (started || !current()) return { status: 'stopped' };
+ started = true;
+ try {
+ const loaded = await loadPrivateRecord(
+ repository,
+ 'received_envelopes',
+ id
+ );
+ if (!current()) return { status: 'stopped' };
+ if (!loaded.ok)
+ return {
+ status:
+ loaded.reason === 'invalid_record' ? 'lost_evidence' : loaded.reason
+ };
+ const record = privateRecordSnapshot(loaded.value, ownership.owner, id),
+ storedWire = privateRecordWire(loaded.value, ownership.owner, id);
+ if (!record || record.family !== 'received_envelope' || !storedWire)
+ return { status: 'invalid_scope' };
+ const outer = outerLayer(record.outer, ownership.owner);
+ if (!outer || outer.id !== id) return { status: 'mismatch' };
+ const scheduler = browserExtensionScheduler();
+ if (!scheduler) return { status: 'unavailable' };
+ const result = await runExtensionAction(
+ scheduler,
+ {
+ owner: ownership.owner,
+ session: ownership.session,
+ operation: Symbol()
+ },
+ current,
+ async (action): Promise<ReceivedUnwrapResult> => {
+ active = action;
+ if (!(await fresh(action))) return { status: 'stopped' };
+ const outerPort = port();
+ if (!outerPort || !current()) return { status: 'stopped' };
+ const opened = await callExtension(action, 'decrypt', () =>
+ outerPort.decrypt(outer.pubkey, outer.content)
+ );
+ if (!current()) return { status: 'stopped' };
+ if (opened.status !== 'settled' || !opened.current)
+ return {
+ status: opened.status === 'denied' ? 'refused' : 'stopped'
+ };
+ const seal = sealLayer(opened.value);
+ if (!seal || typeof opened.value !== 'string')
+ return { status: 'mismatch' };
+ const sealWire = opened.value;
+ 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' ||
+ !rumorLayer(decrypted.value, seal.pubkey)
+ )
+ return { status: 'mismatch' };
+ const rumorWire = decrypted.value;
+ if (!(await fresh(action))) return { status: 'stopped' };
+ const readback = await loadPrivateRecord(
+ repository,
+ 'received_envelopes',
+ id
+ );
+ if (!current()) return { status: 'stopped' };
+ if (!readback.ok)
+ return {
+ status:
+ readback.reason === 'invalid_record'
+ ? 'lost_evidence'
+ : readback.reason
+ };
+ if (
+ privateRecordWire(readback.value, ownership.owner, id) !==
+ storedWire
+ )
+ return { status: 'conflict' };
+ // Last actual storage readback is followed by no SDK/asynchronous
+ // wait before minting original retained-record custody.
+ const token = Object.freeze({}) as ReceivedNestedEnvelope;
+ nested.set(token, {
+ snapshot: {
+ owner: ownership.owner,
+ outerId: id,
+ outerWire: record.outer,
+ sealWire,
+ rumorWire
+ },
+ current
+ });
+ proof = token;
+ return { status: 'authenticated', envelope: token };
+ }
+ );
+ if (!current()) return { status: 'stopped' };
+ if (result.status === 'busy') return { status: 'busy' };
+ return result.status === 'completed' && 'value' in result && result.value
+ ? result.value
+ : { status: result.status === 'denied' ? 'refused' : 'stopped' };
+ } catch {
+ return { status: current() ? 'mismatch' : 'stopped' };
+ } finally {
+ active = undefined;
+ if (!proof) {
+ unsubscribe();
+ unsubscribe = () => {};
+ }
+ }
+ }
+ const token = Object.freeze({}) as ReceivedUnwrap;
+ readers.set(token, { run, stop });
+ unsubscribe = subscribeIdentityInvalidation(session, () => {
+ if (!ownership.current()) stop(false);
+ });
+ return current() ? token : undefined;
+}
+export function unwrapReceivedEnvelope(
+ reader: ReceivedUnwrap
+): Promise<ReceivedUnwrapResult> {
+ return readers.get(reader)?.run() ?? Promise.resolve({ status: 'invalid' });
+}
+export function stopReceivedUnwrap(reader: ReceivedUnwrap): void {
+ readers.get(reader)?.stop(false);
+}
+export function expireReceivedUnwrapWait(reader: ReceivedUnwrap): void {
+ readers.get(reader)?.stop(true);
+}
+export function receivedNestedEnvelopeSnapshot(
+ token: ReceivedNestedEnvelope
+): Snapshot | undefined {
+ const saved = nested.get(token);
+ return saved?.current()
+ ? (JSON.parse(JSON.stringify(saved.snapshot)) as Snapshot)
+ : undefined;
+}
diff --git a/web/tests/conformance/received-envelopes.test.ts b/web/tests/conformance/received-envelopes.test.ts
@@ -0,0 +1,231 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+ generateSecretKey,
+ getPublicKey,
+ getEventHash,
+ finalizeEvent,
+ type UnsignedEvent
+} from 'applesauce-core/helpers';
+import { nip44 } from 'applesauce-core/helpers/encryption';
+import { verifyReceivedLayerData } from '../../src/lib/nostr/unwrap-admission.ts';
+function fixture() {
+ const keys = [generateSecretKey(), generateSecretKey(), generateSecretKey()],
+ sender = getPublicKey(keys[0]),
+ owner = getPublicKey(keys[1]);
+ const template: UnsignedEvent = {
+ pubkey: sender,
+ kind: 14,
+ created_at: 1700000000,
+ tags: [['p', owner]],
+ content: 'Bounded inbound enquiry'
+ };
+ const rumor = { id: getEventHash(template), ...template };
+ const conversation = nip44.v2.utils.getConversationKey(keys[0], owner);
+ let content: string;
+ try {
+ content = nip44.v2.encrypt(JSON.stringify(rumor), conversation);
+ } finally {
+ conversation.fill(0);
+ }
+ const seal = finalizeEvent(
+ { kind: 13, created_at: 1699999900, tags: [], content },
+ keys[0]
+ );
+ const wrapConversation = nip44.v2.utils.getConversationKey(keys[2], owner);
+ let outerContent: string;
+ try {
+ outerContent = nip44.v2.encrypt(JSON.stringify(seal), wrapConversation);
+ } finally {
+ wrapConversation.fill(0);
+ }
+ const outer = finalizeEvent(
+ {
+ kind: 1059,
+ created_at: 1699999800,
+ tags: [['p', owner]],
+ content: outerContent
+ },
+ keys[2]
+ );
+ const check = (r: unknown = rumor, s: unknown = seal, o: unknown = outer) =>
+ verifyReceivedLayerData(
+ JSON.stringify(o),
+ JSON.stringify(s),
+ JSON.stringify(r),
+ owner
+ );
+ return {
+ keys,
+ sender,
+ owner,
+ rumor,
+ seal,
+ outer,
+ check,
+ close() {
+ keys.forEach((k) => k.fill(0));
+ }
+ };
+}
+async function vector(
+ name: string,
+ run: (f: ReturnType<typeof fixture>) => void
+) {
+ await test(name, () => {
+ const f = fixture();
+ try {
+ run(f);
+ } finally {
+ f.close();
+ }
+ });
+}
+await vector(
+ 'actual signed layers and freshly hashed unsigned pair rumor pass detached inspection',
+ (f) => assert.equal(f.check(), true)
+);
+await vector(
+ 'forged inner author fails even after recomputing rumor hash',
+ (f) => {
+ const r = { ...f.rumor, pubkey: f.owner };
+ r.id = getEventHash(r);
+ assert.equal(f.check(r), false);
+ }
+);
+await vector('forged seal signature fails before nested rumor admission', (f) =>
+ assert.equal(f.check(f.rumor, { ...f.seal, sig: '0'.repeat(128) }), false)
+);
+await vector(
+ 'a valid differently signed seal cannot authenticate original rumor author',
+ (f) =>
+ assert.equal(
+ f.check(f.rumor, finalizeEvent({ ...f.seal }, f.keys[1])),
+ false
+ )
+);
+await vector('supplied rumor id is never a cache identity substitute', (f) =>
+ assert.equal(f.check({ ...f.rumor, id: '0'.repeat(64) }), false)
+);
+await vector(
+ 'signed rumor is unsupported rather than silently accepted as unsigned14',
+ (f) => assert.equal(f.check(finalizeEvent({ ...f.rumor }, f.keys[0])), false)
+);
+await vector('wrong kind and file metadata are isolated', (f) => {
+ const r = {
+ ...f.rumor,
+ kind: 15,
+ tags: [...f.rumor.tags, ['file', 'https://example.org/a']]
+ };
+ r.id = getEventHash(r);
+ assert.equal(f.check(r), false);
+});
+await vector('group fanout cannot become an admitted pair rumor', (f) => {
+ const r = {
+ ...f.rumor,
+ tags: [...f.rumor.tags, ['p', getPublicKey(f.keys[2])]]
+ };
+ r.id = getEventHash(r);
+ assert.equal(f.check(r), false);
+});
+await vector('self-only participants are unsupported', (f) => {
+ const r = { ...f.rumor, tags: [['p', f.sender]] };
+ r.id = getEventHash(r);
+ assert.equal(f.check(r), false);
+});
+await vector('nonempty seal tags are rejected despite a valid signature', (f) =>
+ assert.equal(
+ f.check(
+ f.rumor,
+ finalizeEvent({ ...f.seal, tags: [['client', 'unsupported']] }, f.keys[0])
+ ),
+ false
+ )
+);
+await vector(
+ 'wrong outer destination cannot cross owner-scoped admission',
+ (f) =>
+ assert.equal(
+ f.check(
+ f.rumor,
+ f.seal,
+ finalizeEvent({ ...f.outer, tags: [['p', f.sender]] }, f.keys[2])
+ ),
+ false
+ )
+);
+await vector('body and layer bounds are checked without truncation', (f) => {
+ const r = { ...f.rumor, content: 'x'.repeat(4097) };
+ r.id = getEventHash(r);
+ assert.equal(f.check(r), false);
+ assert.equal(
+ verifyReceivedLayerData(
+ JSON.stringify(f.outer),
+ JSON.stringify(f.seal),
+ 'x'.repeat(8193),
+ f.owner
+ ),
+ false
+ );
+});
+await vector(
+ 'caller objects and imported or persisted verification markers cannot bypass fresh parsing',
+ (f) => {
+ let calls = 0;
+ const value = {
+ ...f.rumor,
+ toJSON() {
+ calls++;
+ return f.rumor;
+ }
+ };
+ assert.equal(
+ verifyReceivedLayerData(
+ JSON.stringify(f.outer),
+ JSON.stringify(f.seal),
+ value,
+ f.owner
+ ),
+ false
+ );
+ assert.equal(calls, 0);
+ assert.equal(f.check({ ...f.rumor, verified: true }), false);
+ }
+);
+await vector(
+ 'harmless JSON whitespace works while duplicate fields and noncanonical numeric lexemes fail',
+ (f) => {
+ const o = JSON.stringify(f.outer),
+ s = JSON.stringify(f.seal),
+ r = JSON.stringify(f.rumor);
+ assert.equal(
+ verifyReceivedLayerData(
+ ' ' + o + '\n',
+ '\n' + s,
+ JSON.stringify(f.rumor, null, 2),
+ f.owner
+ ),
+ true
+ );
+ assert.equal(
+ verifyReceivedLayerData(
+ o,
+ s,
+ r.replace('"kind":14', '"kind":15,"kind":14'),
+ f.owner
+ ),
+ false
+ );
+ assert.equal(
+ verifyReceivedLayerData(o, s, r.replace('1700000000', '17e8'), f.owner),
+ false
+ );
+ assert.deepEqual(
+ [
+ verifyReceivedLayerData(o, s, '{}', f.owner),
+ verifyReceivedLayerData(o, s, r, f.owner)
+ ],
+ [false, true]
+ );
+ }
+);
diff --git a/web/tests/e2e/harness/received-envelopes.ts b/web/tests/e2e/harness/received-envelopes.ts
@@ -0,0 +1,149 @@
+import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts';
+import {
+ createPrivateSession,
+ closePrivateSession
+} from '../../../src/lib/runtime/private-session.ts';
+import {
+ admitInboxEnvelope,
+ retainInboxEnvelope
+} from '../../../src/lib/persistence/inbox-envelope-repository.ts';
+import {
+ loadPrivateRecord,
+ commitPrivateRecord
+} from '../../../src/lib/persistence/private-storage.ts';
+import {
+ privateRecordSnapshot,
+ decodePrivateRecord
+} from '../../../src/lib/persistence/private-records.ts';
+import {
+ captureReceivedUnwrap,
+ unwrapReceivedEnvelope,
+ stopReceivedUnwrap,
+ receivedNestedEnvelopeSnapshot,
+ type ReceivedUnwrap,
+ type ReceivedNestedEnvelope
+} from '../../../src/lib/nostr/unwrap-admission.ts';
+export async function makeFixture() {
+ const f = await makeRecoveryFixture(),
+ privateSession = await createPrivateSession(
+ f.identity,
+ 'reviewed_private_session'
+ );
+ if (!privateSession) throw Error('missing genuine private session');
+ const self = (await f.row())!.record.self,
+ admitted = admitInboxEnvelope(
+ self.wire,
+ f.owner,
+ 'wss://archive.example.org',
+ 100
+ );
+ if (!admitted) throw Error('missing admitted real outer');
+ const saved = await retainInboxEnvelope(
+ f.repository,
+ privateSession,
+ admitted
+ );
+ if (saved.status !== 'retained' && saved.status !== 'duplicate')
+ throw Error('no actual retained outer');
+ let reader: ReceivedUnwrap | undefined,
+ proof: ReceivedNestedEnvelope | undefined;
+ let releaseKey: (() => void) | undefined;
+ let restoreKey = () => {};
+ return {
+ ...f,
+ outerId: self.eventId,
+ capture(review: unknown = 'reviewed_inbox_unlock') {
+ reader = captureReceivedUnwrap(
+ f.repository,
+ f.identity,
+ self.eventId,
+ review
+ );
+ return !!reader;
+ },
+ async run() {
+ if (!reader) return { status: 'invalid' as const };
+ const result = await unwrapReceivedEnvelope(reader);
+ if (result.status === 'authenticated') proof = result.envelope;
+ return {
+ status: result.status,
+ snapshot: proof && receivedNestedEnvelopeSnapshot(proof)
+ };
+ },
+ stop() {
+ if (reader) stopReceivedUnwrap(reader);
+ },
+ snapshot() {
+ return proof && receivedNestedEnvelopeSnapshot(proof);
+ },
+ forged() {
+ return receivedNestedEnvelopeSnapshot({} as ReceivedNestedEnvelope);
+ },
+ holdFinalKey() {
+ const provider = window.nostr as
+ { getPublicKey: () => Promise<string> } | undefined;
+ if (!provider) throw Error('missing actual fixture provider');
+ const original = provider.getPublicKey;
+ let calls = 0;
+ provider.getPublicKey = async () => {
+ const owner = await original.call(provider);
+ calls++;
+ return calls === 3
+ ? new Promise<string>((resolve) => {
+ releaseKey = () => resolve(owner);
+ })
+ : owner;
+ };
+ restoreKey = () => {
+ provider.getPublicKey = original;
+ };
+ },
+ pendingFinalKey: () => !!releaseKey,
+ settleFinalKey() {
+ const release = releaseKey;
+ releaseKey = undefined;
+ release?.();
+ },
+ countsValue: () => f.counts(),
+ async stored() {
+ const row = await loadPrivateRecord(
+ f.repository,
+ 'received_envelopes',
+ self.eventId
+ );
+ return row.ok
+ ? privateRecordSnapshot(row.value, f.owner, self.eventId)
+ : undefined;
+ },
+ async changeObservedSource() {
+ const old = await loadPrivateRecord(
+ f.repository,
+ 'received_envelopes',
+ self.eventId
+ );
+ if (!old.ok) throw Error('missing actual received row');
+ const record = privateRecordSnapshot(old.value, f.owner, self.eventId);
+ if (!record || record.family !== 'received_envelope')
+ throw Error('wrong received row');
+ const next = decodePrivateRecord(
+ JSON.stringify({
+ ...record,
+ revision: record.revision + 1,
+ sources: [...record.sources, 'wss://peer-inbox.example.org']
+ }),
+ f.owner,
+ self.eventId
+ );
+ if (!next.ok) throw Error('invalid controlled metadata successor');
+ return commitPrivateRecord(f.repository, next.value, old.value);
+ },
+ close() {
+ releaseKey?.();
+ releaseKey = undefined;
+ restoreKey();
+ if (reader) stopReceivedUnwrap(reader);
+ closePrivateSession(privateSession);
+ f.close();
+ }
+ };
+}
diff --git a/web/tests/e2e/received-envelopes.spec.ts b/web/tests/e2e/received-envelopes.spec.ts
@@ -0,0 +1,240 @@
+import { test, expect } from '@playwright/test';
+import { build } from 'vite';
+import { fileURLToPath } from 'node:url';
+import { createStaticHarness } from '../integration/harness/static.ts';
+import type * as Fixture from './harness/received-envelopes.ts';
+declare global {
+ interface Window {
+ hcp091: typeof Fixture;
+ hcp091Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>;
+ hcp091Run?: ReturnType<
+ Awaited<ReturnType<typeof Fixture.makeFixture>>['run']
+ >;
+ }
+}
+let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string;
+test.beforeAll(async () => {
+ server = await createStaticHarness();
+ const result = await build({
+ configFile: false,
+ logLevel: 'silent',
+ build: {
+ write: false,
+ minify: false,
+ lib: {
+ entry: fileURLToPath(
+ new URL('./harness/received-envelopes.ts', import.meta.url)
+ ),
+ name: 'hcp091',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(result) ? result[0] : result;
+ if (!('output' in output)) throw Error('bundle missing');
+ const chunks = output.output.filter((x) => x.type === 'chunk');
+ expect(chunks).toHaveLength(1);
+ bundle = chunks[0].code;
+});
+test.afterAll(async () => {
+ await server.close();
+});
+test.beforeEach(async ({ page }) => {
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+ await page.evaluate(async () => {
+ window.hcp091Fixture = await window.hcp091.makeFixture();
+ });
+});
+test.afterEach(async ({ page }) => {
+ if (!page.isClosed())
+ await page.evaluate(() => window.hcp091Fixture?.close());
+});
+test('stored actual ciphertext is explicitly unlocked with two stock SDK decryptions and no plaintext persistence', async ({
+ page
+}) => {
+ const before = await page.evaluate(() => window.hcp091Fixture.countsValue());
+ const result = await page.evaluate(async () => {
+ const f = window.hcp091Fixture;
+ f.capture();
+ const result = await f.run();
+ return {
+ result,
+ counts: f.countsValue(),
+ stored: await f.stored(),
+ forged: f.forged()
+ };
+ });
+ expect(result.result.status).toBe('authenticated');
+ expect(result.result.snapshot).toBeDefined();
+ expect(result.counts.decrypts).toBe(before.decrypts + 2);
+ expect(result.counts.keys).toBeGreaterThan(before.keys + 1);
+ expect(result.counts.encrypts).toBe(before.encrypts);
+ expect(result.counts.signs).toBe(before.signs);
+ expect(result.stored).toMatchObject({
+ family: 'received_envelope',
+ read: null
+ });
+ expect(result.stored).not.toHaveProperty('body');
+ expect(result.forged).toBeUndefined();
+});
+test('absent explicit unlock cannot capture or decrypt', async ({ page }) => {
+ const r = await page.evaluate(async () => {
+ const f = window.hcp091Fixture,
+ before = f.countsValue();
+ return {
+ capture: f.capture('unreviewed'),
+ result: await f.run(),
+ before,
+ after: f.countsValue()
+ };
+ });
+ expect(r.capture).toBe(false);
+ expect(r.result.status).toBe('invalid');
+ expect(r.after).toEqual(r.before);
+});
+test('one invalid decrypted seal is isolated and a later explicit valid candidate remains usable', async ({
+ page
+}) => {
+ const r = await page.evaluate(async () => {
+ const f = window.hcp091Fixture;
+ f.mode('wrong_plaintext');
+ f.capture();
+ const bad = await f.run();
+ f.mode('normal');
+ f.capture();
+ const good = await f.run();
+ return { bad, good };
+ });
+ expect(r.bad.status).toBe('mismatch');
+ expect(r.bad.snapshot).toBeUndefined();
+ expect(r.good.status).toBe('authenticated');
+});
+test('changed fresh extension owner fences the first decrypt', async ({
+ page
+}) => {
+ const r = await page.evaluate(async () => {
+ const f = window.hcp091Fixture,
+ before = f.countsValue();
+ f.mode('changed_key');
+ f.capture();
+ const result = await f.run();
+ return { result, before, after: f.countsValue() };
+ });
+ expect(r.result.status).toBe('stopped');
+ expect(r.after.decrypts).toBe(r.before.decrypts);
+ expect(r.result.snapshot).toBeUndefined();
+});
+test('actual decryption refusal has no nested proof or automatic follow-up', async ({
+ page
+}) => {
+ const r = await page.evaluate(async () => {
+ const f = window.hcp091Fixture,
+ before = f.countsValue();
+ f.mode('declined_decrypt');
+ f.capture();
+ const result = await f.run();
+ return { result, before, after: f.countsValue() };
+ });
+ expect(r.result.status).toBe('refused');
+ expect(r.after.decrypts).toBe(r.before.decrypts + 1);
+ expect(r.result.snapshot).toBeUndefined();
+});
+test('Stop during actual provider wait cannot mint a proof or schedule inner decryption', async ({
+ page
+}) => {
+ const before = await page.evaluate(() => {
+ const f = window.hcp091Fixture;
+ f.mode('hold_decrypt');
+ f.capture();
+ window.hcp091Run = f.run();
+ return f.countsValue();
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.hcp091Fixture.pending()))
+ .toBe(true);
+ const r = await page.evaluate(async () => {
+ const f = window.hcp091Fixture;
+ f.stop();
+ f.settle();
+ return {
+ result: await window.hcp091Run,
+ counts: f.countsValue(),
+ snapshot: f.snapshot()
+ };
+ });
+ expect(r.result?.status).toBe('stopped');
+ expect(r.counts.decrypts).toBe(before.decrypts + 1);
+ expect(r.snapshot).toBeUndefined();
+});
+test('logout during actual provider wait destroys session-owned nested evidence', async ({
+ page
+}) => {
+ await page.evaluate(() => {
+ const f = window.hcp091Fixture;
+ f.mode('hold_decrypt');
+ f.capture();
+ window.hcp091Run = f.run();
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.hcp091Fixture.pending()))
+ .toBe(true);
+ const result = await page.evaluate(async () => {
+ const f = window.hcp091Fixture;
+ f.disconnect();
+ f.settle();
+ return await window.hcp091Run;
+ });
+ expect(result?.status).toBe('stopped');
+ expect(result?.snapshot).toBeUndefined();
+});
+test('changed actual stored full-wire metadata during decrypt invalidates original custody', async ({
+ page
+}) => {
+ await page.evaluate(() => {
+ const f = window.hcp091Fixture;
+ f.mode('hold_decrypt');
+ f.capture();
+ window.hcp091Run = f.run();
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.hcp091Fixture.pending()))
+ .toBe(true);
+ expect(
+ await page.evaluate(async () => {
+ const f = window.hcp091Fixture;
+ const result = await f.changeObservedSource();
+ f.mode('normal');
+ f.settle();
+ return result.ok;
+ })
+ ).toBe(true);
+ const result = await page.evaluate(async () => await window.hcp091Run);
+ expect(result?.status).toBe('conflict');
+ expect(result?.snapshot).toBeUndefined();
+});
+
+test('actual stored-wire change during held final SDK key check cannot mint current nested custody', async ({
+ page
+}) => {
+ await page.evaluate(() => {
+ const f = window.hcp091Fixture;
+ f.holdFinalKey();
+ f.capture();
+ window.hcp091Run = f.run();
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.hcp091Fixture.pendingFinalKey()))
+ .toBe(true);
+ expect(
+ await page.evaluate(async () => {
+ const f = window.hcp091Fixture;
+ const changed = await f.changeObservedSource();
+ f.settleFinalKey();
+ return changed.ok;
+ })
+ ).toBe(true);
+ const result = await page.evaluate(async () => await window.hcp091Run);
+ expect(result?.status).toBe('conflict');
+ expect(result?.snapshot).toBeUndefined();
+});