commit 98c2ffc30cd752949118153c78b57386e5df2fd7
parent d330d89347a7b6d83a4562477253a1923dd6e2af
Author: triesap <tyson@radroots.org>
Date: Wed, 7 Oct 2026 20:59:22 +0000
messages: verify genuine outbound nested envelopes (HCP-077)
- Compare actual seal and wrapper decryptions to immutable originals
- Verify fresh signatures hashes participants and reservation binding
- Fence Stop expiry and disconnect through actual decrypt settlement
- Qualify genuine proofs rejection cleanup and controlled fixture clocks
Diffstat:
13 files changed, 717 insertions(+), 46 deletions(-)
diff --git a/web/src/lib/nostr/giftwrap-builder.ts b/web/src/lib/nostr/giftwrap-builder.ts
@@ -67,6 +67,11 @@ export function buildPrivateGiftwrap(
if (!privateSealSnapshot(seal)) 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)
+ )
+ return undefined;
const captured = JSON.stringify({
pubkey: author,
kind: 1059,
@@ -140,6 +145,13 @@ export function buildPrivateGiftwrap(
secret?.fill(0);
}
}
+// Returns only the genuine original capability, never disposable key material.
+export function privateGiftwrapSeal(
+ token: PrivateGiftwrap
+): PrivateRecipientSeal | undefined {
+ const saved = wraps.get(token);
+ return saved && privateSealSnapshot(saved.seal) ? saved.seal : undefined;
+}
export function privateGiftwrapSnapshot(
token: PrivateGiftwrap
): Readonly<Omit<Saved, 'seal'>> | undefined {
diff --git a/web/src/lib/nostr/outbound-envelope-layers.ts b/web/src/lib/nostr/outbound-envelope-layers.ts
@@ -0,0 +1,99 @@
+import { getEventHash, type UnsignedEvent } from 'applesauce-core/helpers';
+import { canonicalPublicKey } from '../contracts/public-key.ts';
+import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
+import {
+ messageFromWireParts,
+ messageToWireParts
+} from '../contracts/message-v1/index.ts';
+import { safeUnsignedInteger } from './envelope-bounds.ts';
+import { verifyEnvelope } from './verified-envelope.ts';
+
+function fields(
+ value: unknown,
+ names: string[]
+): value is Record<string, unknown> {
+ if (typeof value !== 'object' || value === null || Array.isArray(value))
+ return false;
+ let count = 0;
+ for (const name in value) {
+ if (!names.includes(name)) return false;
+ count++;
+ }
+ return count === names.length && names.every((name) => name in value);
+}
+// Detached structural/signature inspection only. Ciphertext correspondence and
+// genuine original reservation custody belong to the factory-owned proof.
+export function verifyOutboundLayerData(
+ original: unknown,
+ rumorWire: unknown,
+ sealWire: unknown,
+ outerWire: unknown,
+ author: unknown,
+ recipient: unknown,
+ role: unknown
+): boolean {
+ const owner = canonicalPublicKey(author),
+ peer = canonicalPublicKey(recipient);
+ if (
+ !owner ||
+ !peer ||
+ owner === peer ||
+ (role !== 'peer' && role !== 'self') ||
+ typeof original !== 'string' ||
+ typeof rumorWire !== 'string' ||
+ original !== rumorWire ||
+ !boundedUtf8(rumorWire, 8192) ||
+ typeof sealWire !== 'string' ||
+ !boundedUtf8(sealWire, 16384) ||
+ typeof outerWire !== 'string' ||
+ !boundedUtf8(outerWire, 32768)
+ )
+ return false;
+ try {
+ const rumor: unknown = JSON.parse(rumorWire),
+ seal: unknown = JSON.parse(sealWire),
+ outer: unknown = JSON.parse(outerWire);
+ const unsigned = ['id', 'pubkey', 'created_at', 'kind', 'tags', 'content'],
+ signed = [...unsigned, 'sig'];
+ if (
+ !fields(rumor, unsigned) ||
+ !fields(seal, signed) ||
+ !fields(outer, signed) ||
+ rumor.pubkey !== owner ||
+ rumor.kind !== 14 ||
+ safeUnsignedInteger(rumor.created_at) === undefined ||
+ seal.pubkey !== owner ||
+ seal.kind !== 13 ||
+ !Array.isArray(seal.tags) ||
+ seal.tags.length !== 0 ||
+ outer.kind !== 1059 ||
+ !Array.isArray(outer.tags) ||
+ JSON.stringify(outer.tags) !==
+ JSON.stringify([['p', role === 'self' ? owner : peer]]) ||
+ !verifyEnvelope(sealWire).ok ||
+ !verifyEnvelope(outerWire).ok
+ )
+ return false;
+ const parts = { kind: 14, tags: rumor.tags, content: rumor.content };
+ const decoded = messageFromWireParts(JSON.stringify(parts));
+ if (
+ !decoded ||
+ decoded.recipients.length !== 1 ||
+ decoded.recipients[0].public_key !== peer
+ )
+ return false;
+ const canonical = messageToWireParts(JSON.stringify(decoded));
+ if (!canonical || JSON.stringify(canonical) !== JSON.stringify(parts))
+ return false;
+ const template: UnsignedEvent = {
+ pubkey: owner,
+ created_at: rumor.created_at as number,
+ kind: 14,
+ tags: canonical.tags.map((row) => [...row]),
+ content: canonical.content
+ };
+ return typeof rumor.id === 'string' && rumor.id === getEventHash(template);
+ } catch {
+ return false;
+ }
+}
diff --git a/web/src/lib/nostr/seal-builder.ts b/web/src/lib/nostr/seal-builder.ts
@@ -46,6 +46,7 @@ type SavedSeal = Readonly<{
command: string;
rumorHash: string;
wire: string;
+ reserved: ReservedSendIdentity;
current(): boolean;
}>;
const operations = new WeakMap<PrivateSealOperation, State>();
@@ -165,6 +166,17 @@ export function capturePrivateSealOperation(
return { status: encrypted.status === 'denied' ? 'refused' : 'stopped' };
if (!sealCiphertextV2(encrypted.value)) return { status: 'mismatch' };
if (!(await fresh(action))) return { status: 'stopped' };
+ const decryptPort = cipherPort();
+ if (!decryptPort || !current()) return { status: 'stopped' };
+ const decrypted = await callExtension(action, 'decrypt', () =>
+ decryptPort.decrypt(target, 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)
+ return { status: 'mismatch' };
+ if (!(await fresh(action))) return { status: 'stopped' };
const milliseconds = safeUnsignedInteger(Date.now());
if (milliseconds === undefined || !current()) return { status: 'stopped' };
// Public randomized timing metadata only. Never change the reserved inner
@@ -193,6 +205,7 @@ export function capturePrivateSealOperation(
command: record.id,
rumorHash: record.rumorHash,
wire: signed,
+ reserved,
current
});
return { status: 'sealed', seal };
@@ -257,7 +270,7 @@ export function expirePrivateSealWait(operation: PrivateSealOperation): void {
// Future wrapper/nested owners must retain exact original operation binding.
export function privateSealSnapshot(
seal: PrivateRecipientSeal
-): Readonly<Omit<SavedSeal, 'current'>> | undefined {
+): Readonly<Omit<SavedSeal, 'current' | 'reserved'>> | undefined {
const saved = seals.get(seal);
return saved?.current()
? {
@@ -271,3 +284,10 @@ export function privateSealSnapshot(
}
: undefined;
}
+// Genuine association only; detached snapshots cannot recreate this identity.
+export function privateSealReservation(
+ seal: PrivateRecipientSeal
+): ReservedSendIdentity | undefined {
+ const saved = seals.get(seal);
+ return saved?.current() ? saved.reserved : undefined;
+}
diff --git a/web/src/lib/nostr/verify-outbound-envelope.ts b/web/src/lib/nostr/verify-outbound-envelope.ts
@@ -0,0 +1,76 @@
+import {
+ reservedSendSnapshot,
+ reservedSendRumorWire,
+ type ReservedSendIdentity
+} from '../messaging/send-identity.ts';
+import {
+ privateGiftwrapSnapshot,
+ privateGiftwrapSeal,
+ type PrivateGiftwrap
+} from './giftwrap-builder.ts';
+import { privateSealSnapshot, privateSealReservation } from './seal-builder.ts';
+import { verifyOutboundLayerData } from './outbound-envelope-layers.ts';
+declare const outboundBrand: unique symbol;
+export type VerifiedOutboundEnvelope = Readonly<{ [outboundBrand]: true }>;
+type Saved = Readonly<{
+ reserved: ReservedSendIdentity;
+ wrap: PrivateGiftwrap;
+}>;
+const proofs = new WeakMap<VerifiedOutboundEnvelope, Saved>();
+function inspect(reserved: ReservedSendIdentity, wrap: PrivateGiftwrap) {
+ const record = reservedSendSnapshot(reserved),
+ rumor = reservedSendRumorWire(reserved),
+ outer = privateGiftwrapSnapshot(wrap),
+ seal = privateGiftwrapSeal(wrap),
+ inner = seal && privateSealSnapshot(seal);
+ if (
+ !record ||
+ !rumor ||
+ !outer ||
+ !seal ||
+ !inner ||
+ privateSealReservation(seal) !== reserved ||
+ outer.command !== record.id ||
+ outer.owner !== record.owner ||
+ outer.peer !== record.peer ||
+ outer.rumorHash !== record.rumorHash ||
+ inner.command !== outer.command ||
+ inner.rumorHash !== outer.rumorHash ||
+ inner.role !== outer.role ||
+ inner.destination !== outer.destination ||
+ !verifyOutboundLayerData(
+ rumor,
+ rumor,
+ inner.wire,
+ outer.wire,
+ record.owner,
+ record.peer,
+ outer.role
+ )
+ )
+ return undefined;
+ const original = JSON.parse(rumor) as { id: string; created_at: number };
+ if (
+ original.id !== record.rumorHash ||
+ original.created_at !== record.createdAt
+ )
+ return undefined;
+ return outer;
+}
+// Only genuine current factory roundtrip associations enter this proof. Pure
+// detached validation cannot mint it. No receipt, durability or Send follows.
+export function verifyOutboundEnvelope(
+ reserved: ReservedSendIdentity,
+ wrap: PrivateGiftwrap,
+ review: unknown
+): VerifiedOutboundEnvelope | undefined {
+ if (review !== 'reviewed_outbound_layers' || !inspect(reserved, wrap))
+ return undefined;
+ const token = Object.freeze({}) as VerifiedOutboundEnvelope;
+ proofs.set(token, { reserved, wrap });
+ return token;
+}
+export function verifiedOutboundSnapshot(token: VerifiedOutboundEnvelope) {
+ const saved = proofs.get(token);
+ return saved ? inspect(saved.reserved, saved.wrap) : undefined;
+}
diff --git a/web/tests/conformance/outbound-envelope-layers.test.ts b/web/tests/conformance/outbound-envelope-layers.test.ts
@@ -0,0 +1,154 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+ generateSecretKey,
+ getPublicKey,
+ getEventHash,
+ finalizeEvent,
+ type UnsignedEvent
+} from 'applesauce-core/helpers';
+import { verifyOutboundLayerData } from '../../src/lib/nostr/outbound-envelope-layers.ts';
+
+// Detached real SDK signature vectors only; no genuine preparation authority.
+function fixture() {
+ const keys = [generateSecretKey(), generateSecretKey(), generateSecretKey()];
+ const owner = getPublicKey(keys[0]),
+ peer = getPublicKey(keys[1]);
+ const template: UnsignedEvent = {
+ pubkey: owner,
+ kind: 14,
+ created_at: 1700000000,
+ tags: [['p', peer]],
+ content: 'Original enquiry'
+ };
+ const rumor = { id: getEventHash(template), ...template };
+ const seal = finalizeEvent(
+ {
+ kind: 13,
+ created_at: 1699999900,
+ tags: [],
+ content: 'bounded ciphertext fixture'
+ },
+ keys[0]
+ );
+ const outer = finalizeEvent(
+ {
+ kind: 1059,
+ created_at: 1699999800,
+ tags: [['p', peer]],
+ content: 'bounded outer fixture'
+ },
+ keys[2]
+ );
+ const original = JSON.stringify(rumor);
+ const check = (
+ r: unknown = rumor,
+ s: unknown = seal,
+ w: unknown = outer,
+ role: 'peer' | 'self' = 'peer'
+ ) =>
+ verifyOutboundLayerData(
+ original,
+ JSON.stringify(r),
+ JSON.stringify(s),
+ JSON.stringify(w),
+ owner,
+ peer,
+ role
+ );
+ return {
+ keys,
+ owner,
+ peer,
+ rumor,
+ seal,
+ outer,
+ check,
+ close: () => keys.forEach((k) => k.fill(0))
+ };
+}
+await test('fresh SDK hashes and both signed layers preserve the exact original pair rumor', () => {
+ const f = fixture();
+ try {
+ assert.equal(f.check(), true);
+ const self = finalizeEvent(
+ {
+ kind: 1059,
+ created_at: f.outer.created_at,
+ tags: [['p', f.owner]],
+ content: f.outer.content
+ },
+ f.keys[2]
+ );
+ assert.equal(f.check(f.rumor, f.seal, self, 'self'), true);
+ } finally {
+ f.close();
+ }
+});
+await test('valid signatures do not admit wrong sender, seal tags or outer target', () => {
+ const f = fixture();
+ try {
+ assert.equal(
+ f.check(f.rumor, finalizeEvent({ ...f.seal }, f.keys[1])),
+ false
+ );
+ assert.equal(
+ f.check(
+ f.rumor,
+ finalizeEvent({ ...f.seal, tags: [['client', 'leak']] }, f.keys[0])
+ ),
+ false
+ );
+ assert.equal(
+ f.check(
+ f.rumor,
+ f.seal,
+ finalizeEvent({ ...f.outer, tags: [['p', f.owner]] }, f.keys[2])
+ ),
+ false
+ );
+ assert.equal(
+ f.check(
+ f.rumor,
+ f.seal,
+ finalizeEvent(
+ {
+ ...f.outer,
+ tags: [
+ ['p', f.peer],
+ ['p', f.owner]
+ ]
+ },
+ f.keys[2]
+ )
+ ),
+ false
+ );
+ } finally {
+ f.close();
+ }
+});
+await test('rehashed substitute rumor, third-party fanout and cached wrong ids fail', () => {
+ const f = fixture();
+ try {
+ const substitute = { ...f.rumor, content: 'different enquiry' };
+ substitute.id = getEventHash(substitute);
+ assert.equal(f.check(substitute), false);
+ const fanout = {
+ ...f.rumor,
+ tags: [
+ ['p', f.peer],
+ ['p', f.owner]
+ ]
+ };
+ fanout.id = getEventHash(fanout);
+ assert.equal(f.check(fanout), false);
+ assert.equal(f.check({ ...f.rumor, id: '0'.repeat(64) }), false);
+ assert.equal(
+ f.check(f.rumor, { ...f.seal, id: '0'.repeat(64), verified: true }),
+ false
+ );
+ } finally {
+ f.close();
+ }
+});
diff --git a/web/tests/e2e/harness/giftwrap-builder.ts b/web/tests/e2e/harness/giftwrap-builder.ts
@@ -61,6 +61,9 @@ export type Mode =
| 'changed_key'
| 'hold_encrypt'
| 'hold_sign'
+ | 'wrong_plaintext'
+ | 'declined_decrypt'
+ | 'hold_decrypt'
| 'getter_reentry'
| 'stop_capability_getter'
| 'stop_capability_after_key';
@@ -75,6 +78,7 @@ export async function makeFixture() {
keys = 0,
encrypts = 0,
signs = 0,
+ decrypts = 0,
capabilityReads = 0,
reentrantReads = 0,
postStopEncrypts = 0,
@@ -161,19 +165,34 @@ export async function makeFixture() {
return new Promise<string>((resolve) => {
release = () => resolve(encryptTo(target, text));
});
- return Promise.resolve(encryptTo(target, text));
+ return Promise.resolve(
+ encryptTo(
+ target,
+ mode === 'wrong_plaintext' ? 'substitute rumor' : text
+ )
+ );
};
},
decrypt: (target: string, cipher: string) => {
- const conversation = nip44.v2.utils.getConversationKey(
- secret,
- target
- );
- try {
- return Promise.resolve(nip44.v2.decrypt(cipher, conversation));
- } finally {
- conversation.fill(0);
- }
+ decrypts++;
+ if (mode === 'declined_decrypt')
+ return Promise.reject(Error('decrypt refused'));
+ const decryptNow = () => {
+ const conversation = nip44.v2.utils.getConversationKey(
+ secret,
+ target
+ );
+ try {
+ return nip44.v2.decrypt(cipher, conversation);
+ } finally {
+ conversation.fill(0);
+ }
+ };
+ if (mode === 'hold_decrypt')
+ return new Promise<string>((resolve) => {
+ release = () => resolve(decryptNow());
+ });
+ return Promise.resolve(decryptNow());
}
};
}
@@ -207,11 +226,12 @@ export async function makeFixture() {
if (!proof.ok) throw Error('invalid public fixture');
const context = captureEnquiryContext(proof.value);
if (!context) throw Error('invalid context');
+ const reservationTime = Date.now();
const plan = captureEnquiryRumor(
identity,
context,
'Private seal sentinel',
- Math.floor(Date.now() / 1000)
+ Math.floor(reservationTime / 1000)
);
if (!plan) throw Error('missing plan');
const opened = await openBrowserDatabase();
@@ -219,14 +239,24 @@ export async function makeFixture() {
const database = opened.owner,
repository = createPrivateSendReservationRepository(database, owner);
if (!repository) throw Error('missing repository');
- const reservation = await reserveSendIdentity(
- repository,
- identity,
- '12345678-1234-4234-8234-123456789abc',
- plan,
- 'reviewed_private_intent'
- );
- if (reservation.status !== 'reserved') throw Error('missing reservation');
+ // Controlled fixture second across actual asynchronous IDB/WebLock setup.
+ // Production admission still requires its real current observed second.
+ const liveNow = Date.now;
+ let reservation: Awaited<ReturnType<typeof reserveSendIdentity>>;
+ Date.now = () => reservationTime;
+ try {
+ reservation = await reserveSendIdentity(
+ repository,
+ identity,
+ '12345678-1234-4234-8234-123456789abc',
+ plan,
+ 'reviewed_private_intent'
+ );
+ } finally {
+ Date.now = liveNow;
+ }
+ if (reservation.status !== 'reserved')
+ throw Error('missing reservation: ' + reservation.status);
const reserved = reservation.identity;
const original = reservedSendRumorWire(reserved);
return {
@@ -234,6 +264,18 @@ export async function makeFixture() {
peer,
identity,
reserved,
+ async reserveAgain() {
+ const result = await reserveSendIdentity(
+ repository,
+ identity,
+ '12345678-1234-4234-8234-123456789abc',
+ plan,
+ 'reviewed_private_intent'
+ );
+ if (result.status !== 'existing' && result.status !== 'reserved')
+ throw Error('missing second reservation');
+ return result.identity;
+ },
operation: (
role: unknown = 'peer',
review: unknown = 'reviewed_private_seal'
@@ -245,7 +287,14 @@ export async function makeFixture() {
mode = value;
capabilityReads = 0;
},
- counts: () => ({ keys, encrypts, signs, reentrantReads, postStopEncrypts }),
+ counts: () => ({
+ keys,
+ encrypts,
+ decrypts,
+ signs,
+ reentrantReads,
+ postStopEncrypts
+ }),
identityState: () => identitySessionSnapshot(identity).state,
settle: () => {
release?.();
diff --git a/web/tests/e2e/harness/outbound-envelope.ts b/web/tests/e2e/harness/outbound-envelope.ts
@@ -0,0 +1,5 @@
+export * from './giftwrap-builder.ts';
+export {
+ verifyOutboundEnvelope,
+ verifiedOutboundSnapshot
+} from '../../../src/lib/nostr/verify-outbound-envelope.ts';
diff --git a/web/tests/e2e/harness/seal-builder.ts b/web/tests/e2e/harness/seal-builder.ts
@@ -56,6 +56,9 @@ export type Mode =
| 'changed_key'
| 'hold_encrypt'
| 'hold_sign'
+ | 'wrong_plaintext'
+ | 'declined_decrypt'
+ | 'hold_decrypt'
| 'getter_reentry'
| 'stop_capability_getter'
| 'stop_capability_after_key';
@@ -70,6 +73,7 @@ export async function makeFixture() {
keys = 0,
encrypts = 0,
signs = 0,
+ decrypts = 0,
capabilityReads = 0,
reentrantReads = 0,
postStopEncrypts = 0,
@@ -156,19 +160,34 @@ export async function makeFixture() {
return new Promise<string>((resolve) => {
release = () => resolve(encryptTo(target, text));
});
- return Promise.resolve(encryptTo(target, text));
+ return Promise.resolve(
+ encryptTo(
+ target,
+ mode === 'wrong_plaintext' ? 'substitute rumor' : text
+ )
+ );
};
},
decrypt: (target: string, cipher: string) => {
- const conversation = nip44.v2.utils.getConversationKey(
- secret,
- target
- );
- try {
- return Promise.resolve(nip44.v2.decrypt(cipher, conversation));
- } finally {
- conversation.fill(0);
- }
+ decrypts++;
+ if (mode === 'declined_decrypt')
+ return Promise.reject(Error('decrypt refused'));
+ const decryptNow = () => {
+ const conversation = nip44.v2.utils.getConversationKey(
+ secret,
+ target
+ );
+ try {
+ return nip44.v2.decrypt(cipher, conversation);
+ } finally {
+ conversation.fill(0);
+ }
+ };
+ if (mode === 'hold_decrypt')
+ return new Promise<string>((resolve) => {
+ release = () => resolve(decryptNow());
+ });
+ return Promise.resolve(decryptNow());
}
};
}
@@ -202,11 +221,12 @@ export async function makeFixture() {
if (!proof.ok) throw Error('invalid public fixture');
const context = captureEnquiryContext(proof.value);
if (!context) throw Error('invalid context');
+ const reservationTime = Date.now();
const plan = captureEnquiryRumor(
identity,
context,
'Private seal sentinel',
- Math.floor(Date.now() / 1000)
+ Math.floor(reservationTime / 1000)
);
if (!plan) throw Error('missing plan');
const opened = await openBrowserDatabase();
@@ -214,14 +234,24 @@ export async function makeFixture() {
const database = opened.owner,
repository = createPrivateSendReservationRepository(database, owner);
if (!repository) throw Error('missing repository');
- const reservation = await reserveSendIdentity(
- repository,
- identity,
- '12345678-1234-4234-8234-123456789abc',
- plan,
- 'reviewed_private_intent'
- );
- if (reservation.status !== 'reserved') throw Error('missing reservation');
+ // Controlled fixture second across actual asynchronous IDB/WebLock setup.
+ // Production admission still requires its real current observed second.
+ const liveNow = Date.now;
+ let reservation: Awaited<ReturnType<typeof reserveSendIdentity>>;
+ Date.now = () => reservationTime;
+ try {
+ reservation = await reserveSendIdentity(
+ repository,
+ identity,
+ '12345678-1234-4234-8234-123456789abc',
+ plan,
+ 'reviewed_private_intent'
+ );
+ } finally {
+ Date.now = liveNow;
+ }
+ if (reservation.status !== 'reserved')
+ throw Error('missing reservation: ' + reservation.status);
const reserved = reservation.identity;
const original = reservedSendRumorWire(reserved);
return {
@@ -240,7 +270,14 @@ export async function makeFixture() {
mode = value;
capabilityReads = 0;
},
- counts: () => ({ keys, encrypts, signs, reentrantReads, postStopEncrypts }),
+ counts: () => ({
+ keys,
+ encrypts,
+ decrypts,
+ signs,
+ reentrantReads,
+ postStopEncrypts
+ }),
identityState: () => identitySessionSnapshot(identity).state,
settle: () => {
release?.();
diff --git a/web/tests/e2e/outbound-envelope.spec.ts b/web/tests/e2e/outbound-envelope.spec.ts
@@ -0,0 +1,191 @@
+import { test, expect, type Page } from '@playwright/test';
+import { build } from 'vite';
+import { fileURLToPath } from 'node:url';
+import { createStaticHarness } from '../integration/harness/static.ts';
+import type * as Layers from './harness/outbound-envelope.ts';
+declare global {
+ interface Window {
+ hcp077: typeof Layers;
+ hcp077Fixture: Awaited<ReturnType<typeof Layers.makeFixture>>;
+ hcp077Operation: Parameters<typeof Layers.stopPrivateSeal>[0];
+ hcp077Job: ReturnType<typeof Layers.buildPrivateSeal>;
+ }
+}
+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/outbound-envelope.ts', import.meta.url)
+ ),
+ name: 'hcp077',
+ formats: ['iife']
+ }
+ }
+ });
+ const output = Array.isArray(result) ? result[0] : result;
+ if (!('output' in output)) throw Error('missing bundle');
+ const chunks = output.output.filter((x) => x.type === 'chunk');
+ expect(chunks).toHaveLength(1);
+ bundle = chunks[0].code;
+});
+test.afterAll(async () => server.close());
+async function load(page: Page) {
+ await page.goto(server.url + '/search');
+ await page.addScriptTag({ content: bundle });
+ await page.evaluate(async () => {
+ window.hcp077Fixture = await window.hcp077.makeFixture();
+ });
+}
+for (const role of ['peer', 'self'] as const)
+ test(`genuine ${role} nested proof binds original reservation and expires on disconnect`, async ({
+ page
+ }) => {
+ await load(page);
+ const result = await page.evaluate(async (role) => {
+ const f = window.hcp077Fixture,
+ s = window.hcp077;
+ try {
+ const op = f.operation(role);
+ if (!op) throw Error('missing operation');
+ const sealed = await s.buildPrivateSeal(op);
+ if (sealed.status !== 'sealed') throw Error('missing seal');
+ const wrap = s.buildPrivateGiftwrap(
+ sealed.seal,
+ 'reviewed_private_wrap'
+ );
+ if (!wrap) throw Error('missing wrap');
+ const proof = s.verifyOutboundEnvelope(
+ f.reserved,
+ wrap,
+ 'reviewed_outbound_layers'
+ );
+ const snapshot = proof && s.verifiedOutboundSnapshot(proof);
+ const cast = s.verifyOutboundEnvelope(
+ f.reserved,
+ {} as typeof wrap,
+ 'reviewed_outbound_layers'
+ );
+ const wrongReview = s.verifyOutboundEnvelope(f.reserved, wrap, 'wrong');
+ const second = await f.reserveAgain();
+ const wrongReservation = s.verifyOutboundEnvelope(
+ second,
+ wrap,
+ 'reviewed_outbound_layers'
+ );
+ f.disconnect();
+ return {
+ admitted: !!snapshot,
+ role: snapshot?.role,
+ cast: !!cast,
+ wrongReview: !!wrongReview,
+ differentGenuineReservation: second !== f.reserved,
+ wrongReservation: !!wrongReservation,
+ expired: proof && !s.verifiedOutboundSnapshot(proof)
+ };
+ } finally {
+ f.close();
+ }
+ }, role);
+ expect(result).toEqual({
+ admitted: true,
+ role,
+ cast: false,
+ wrongReview: false,
+ differentGenuineReservation: true,
+ wrongReservation: false,
+ expired: true
+ });
+ });
+for (const mode of ['wrong_plaintext', 'declined_decrypt'] as const)
+ test(`actual ${mode} never spends SIGN or grants a sender seal`, async ({
+ page
+ }) => {
+ await load(page);
+ const result = await page.evaluate(async (mode) => {
+ const f = window.hcp077Fixture;
+ try {
+ const op = f.operation();
+ if (!op) throw Error('missing operation');
+ f.mode(mode);
+ const before = f.counts(),
+ identity = f.identityState();
+ const result = await window.hcp077.buildPrivateSeal(op),
+ after = f.counts();
+ return {
+ status: result.status,
+ signs: after.signs - before.signs,
+ decrypts: after.decrypts - before.decrypts,
+ identityPreserved: f.identityState() === identity
+ };
+ } finally {
+ f.close();
+ }
+ }, mode);
+ expect(result.status).toBe(
+ mode === 'wrong_plaintext' ? 'mismatch' : 'refused'
+ );
+ expect(result.signs).toBe(0);
+ expect(result.decrypts).toBe(1);
+ expect(result.identityPreserved).toBe(true);
+ });
+for (const action of ['stop', 'expire'] as const)
+ test(`${action} during actual decrypt keeps slot and owner lock until settlement without late SIGN`, async ({
+ page
+ }) => {
+ await load(page);
+ await page.evaluate(() => {
+ const f = window.hcp077Fixture,
+ op = f.operation();
+ if (!op) throw Error('missing operation');
+ f.mode('hold_decrypt');
+ window.hcp077Operation = op;
+ window.hcp077Job = window.hcp077.buildPrivateSeal(op);
+ });
+ await expect
+ .poll(() => page.evaluate(() => window.hcp077Fixture.slot()))
+ .toMatchObject({ state: 'active', pending: 'decrypt' });
+ const pending = await page.evaluate(async (action) => {
+ const f = window.hcp077Fixture,
+ s = window.hcp077,
+ identity = f.identityState();
+ if (action === 'expire') s.expirePrivateSealWait(window.hcp077Operation);
+ else s.stopPrivateSeal(window.hcp077Operation);
+ const other = f.operation();
+ if (!other) throw Error('missing contender');
+ return {
+ slot: f.slot(),
+ busy: (await s.buildPrivateSeal(other)).status,
+ identityPreserved: f.identityState() === identity
+ };
+ }, action);
+ expect(pending.slot).toMatchObject({ state: 'active', pending: 'decrypt' });
+ expect(pending.busy).toBe('busy');
+ expect(pending.identityPreserved).toBe(true);
+ const settled = await page.evaluate(async () => {
+ const f = window.hcp077Fixture,
+ before = f.counts();
+ try {
+ f.settle();
+ const result = await window.hcp077Job;
+ return {
+ status: result.status,
+ slot: f.slot(),
+ unchanged: JSON.stringify(before) === JSON.stringify(f.counts())
+ };
+ } finally {
+ f.close();
+ }
+ });
+ expect(settled).toEqual({
+ status: 'stopped',
+ slot: { state: 'idle' },
+ unchanged: true
+ });
+ });
diff --git a/web/tests/e2e/seal-builder.spec.ts b/web/tests/e2e/seal-builder.spec.ts
@@ -109,7 +109,7 @@ for (const role of ['peer', 'self'] as const)
randomizedBounds: true,
signs: 1,
encrypts: 1,
- keys: 3,
+ keys: 4,
again: 'stopped'
});
expect(result.target).toBe(result.expected);
@@ -180,7 +180,7 @@ test('detached reservation, wrong role or absent explicit review cannot acquire
});
expect(result).toEqual({ absent: true, same: true });
});
-for (const phase of ['hold_encrypt', 'hold_sign'] as const)
+for (const phase of ['hold_encrypt', 'hold_decrypt', 'hold_sign'] as const)
test(`disconnect during ${phase} retains real slot until settlement and fences late result`, async ({
page
}) => {
@@ -197,7 +197,12 @@ for (const phase of ['hold_encrypt', 'hold_sign'] as const)
.poll(() => page.evaluate(() => window.hcp075Fixture.slot()))
.toMatchObject({
state: 'active',
- pending: phase === 'hold_encrypt' ? 'encrypt' : 'sign'
+ pending:
+ phase === 'hold_encrypt'
+ ? 'encrypt'
+ : phase === 'hold_decrypt'
+ ? 'decrypt'
+ : 'sign'
});
const pending = await page.evaluate(() => {
const f = window.hcp075Fixture;
diff --git a/web/tests/provenance/source-boundaries.test.mjs b/web/tests/provenance/source-boundaries.test.mjs
@@ -2101,7 +2101,8 @@ test('history scroll owner rejects malformed values without coercion or SSR effe
test(
'HCP076 allows only the byte-pinned disposable gift-wrap producer and rejects key escape or copied construction',
- { timeout: 30000 },
+ // Nine sequential audits retain8s each, plus bounded real fixture setup.
+ { timeout: 90000 },
async () => {
await fixture(async ({ directory, put, execute }) => {
await confineSvelte(directory);
@@ -2131,6 +2132,7 @@ test(
for (const alteration of [
source + '\nexport const secret = generateSecretKey();',
source.replace('secret?.fill(0);', '// cleanup removed'),
+ source.replace('nip44.v2.decrypt(', 'nip44.v2.encrypt('),
source.replace('kind: 1059,', 'kind: 14,'),
source.replace(
"tags: [['p', record.destination]],",
@@ -2142,6 +2144,7 @@ test(
),
source.replace("'applesauce-core/helpers'", "'nostr-tools/pure'")
]) {
+ assert.notEqual(alteration, source);
await put(name, alteration);
reject(execute(), /gift-wrap construction source identity/);
}
diff --git a/web/tests/unit/giftwrap-builder.test.ts b/web/tests/unit/giftwrap-builder.test.ts
@@ -258,3 +258,23 @@ for (const response of ['wrong_target', 'cached_bad_id'] as const)
expect(state.conversations[0].every((x) => x === 0)).toBe(true);
f.key.fill(0);
});
+for (const fault of ['mismatch', 'exception'] as const)
+ it(`outer roundtrip ${fault} clears directly owned buffers and grants no wrapper`, () => {
+ vi.stubGlobal('window', {});
+ const f = fixture();
+ const spy = vi.spyOn(nip44.v2, 'decrypt').mockImplementation(() => {
+ if (fault === 'exception') throw Error('SDK roundtrip fault');
+ return 'substitute signed seal';
+ });
+ try {
+ expect(
+ buildPrivateGiftwrap(f.seal, 'reviewed_private_wrap')
+ ).toBeUndefined();
+ expect(state.keys).toHaveLength(1);
+ expect(state.keys[0].every((x) => x === 0)).toBe(true);
+ expect(state.conversations[0].every((x) => x === 0)).toBe(true);
+ } finally {
+ spy.mockRestore();
+ f.key.fill(0);
+ }
+ });
diff --git a/web/tools/source-boundaries.mjs b/web/tools/source-boundaries.mjs
@@ -1555,7 +1555,7 @@ export async function auditSource(root) {
const giftwrapTrusted =
files.has(giftwrapFile) &&
createHash('sha256').update(files.get(giftwrapFile)).digest('hex') ===
- '7f22b02cc21bb2cfaca4d984ea3fe94ed92420aad8235901d1819880396fe245';
+ '866d53d993f40edc15828fcf279c03b35258cc3e5de8f555ac95339f846ac9f3';
if (files.has(giftwrapFile) && !giftwrapTrusted)
complain(
giftwrapFile,