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