app

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

inbox-probe-nonce.spec.ts (34780B)


      1 import { test, expect } from '@playwright/test';
      2 import { build } from 'vite';
      3 import { once } from 'node:events';
      4 import { fileURLToPath } from 'node:url';
      5 import { WebSocketServer, type WebSocket } from 'ws';
      6 import { createStaticHarness } from '../integration/harness/static.ts';
      7 import type * as Fixture from './harness/inbox-probe-nonce.ts';
      8 declare global {
      9   interface Window {
     10     nc: typeof Fixture;
     11     ncFixture: Awaited<ReturnType<typeof Fixture.makeNonceFixture>>;
     12     ncPending?: Promise<unknown>;
     13     ncAbort?: AbortController;
     14     ncOtherPool?: Fixture.PrivatePool;
     15     ncRestore?: () => void;
     16     ncAdvancePage?: () => void;
     17     ncAdvanceOnSocket?: 'network' | 'page';
     18     ncClock?: number;
     19     ncNetworkClock?: ReturnType<Window['ncFixture']['installNetworkClock']>;
     20     ncDelayClose?: boolean;
     21     ncFailClose?: boolean;
     22     ncInvalidateOnSocket?: boolean;
     23     ncNestedCleanup?: number;
     24     ncNestedFailure?: number;
     25     ncHeldClose?: (() => void)[];
     26     ncNoncePending?: Promise<unknown>;
     27     ncNonceOther?: Promise<unknown>;
     28   }
     29 }
     30 let server: Awaited<ReturnType<typeof createStaticHarness>>,
     31   sockets: WebSocketServer,
     32   endpoint: string,
     33   bundle: string;
     34 let readMode = 'exact';
     35 const archived = new Map<string, Record<string, unknown>>();
     36 let head = '',
     37   response: 'accepted' | 'refused' | 'unknown' | 'wrong' | 'auth_required' =
     38     'accepted',
     39   auth = false;
     40 const frames: { origin: string; frame: unknown[] }[] = [],
     41   physical = new Set<WebSocket>();
     42 let peak = 0,
     43   privatePeak = 0;
     44 const privatePhysical = new Set<WebSocket>();
     45 const privateConnections = new Map<string, number>();
     46 test.beforeAll(async () => {
     47   server = await createStaticHarness();
     48   sockets = new WebSocketServer({
     49     host: '127.0.0.1',
     50     port: 0,
     51     maxPayload: 65536
     52   });
     53   await once(sockets, 'listening');
     54   const address = sockets.address();
     55   if (!address || typeof address === 'string')
     56     throw Error('actual loorback fixture');
     57   endpoint = 'ws://127.0.0.1:' + address.port;
     58   sockets.on('connection', (socket, request) => {
     59     physical.add(socket);
     60     peak = Math.max(peak, physical.size);
     61     socket.on('close', () => physical.delete(socket));
     62     const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get(
     63       'origin'
     64     )!;
     65     if (origin !== 'wss://discovery.example.org') {
     66       privatePhysical.add(socket);
     67       privateConnections.set(origin, (privateConnections.get(origin) ?? 0) + 1);
     68       privatePeak = Math.max(privatePeak, privatePhysical.size);
     69       socket.on('close', () => privatePhysical.delete(socket));
     70     }
     71     if (auth && origin === 'wss://inbox.example.org')
     72       socket.send(JSON.stringify(['AUTH', 'probe-challenge']));
     73     socket.on('message', (bytes) => {
     74       const raw = Buffer.isBuffer(bytes)
     75         ? bytes
     76         : Array.isArray(bytes)
     77           ? Buffer.concat(bytes)
     78           : Buffer.from(bytes);
     79       const frame = JSON.parse(raw.toString()) as unknown[];
     80       frames.push({ origin, frame });
     81       if (frame[0] === 'REQ') {
     82         const filter = frame[2] as { kinds?: number[]; ids?: string[] };
     83         if (filter.kinds?.includes(10050) && head)
     84           socket.send(JSON.stringify(['EVENT', frame[1], JSON.parse(head)]));
     85         if (filter.kinds?.includes(1059)) {
     86           if (readMode === 'refused' || readMode === 'auth_required') {
     87             socket.send(
     88               JSON.stringify([
     89                 'CLOSED',
     90                 frame[1],
     91                 readMode === 'auth_required'
     92                   ? 'auth-required: source fixture'
     93                   : 'blocked source fixture'
     94               ])
     95             );
     96             return;
     97           }
     98           if (readMode === 'unknown') return;
     99           const original = archived.get(filter.ids?.[0] ?? '');
    100           if (original && readMode !== 'empty') {
    101             const event: Record<string, unknown> =
    102               readMode === 'metadata'
    103                 ? {
    104                     sig: original.sig,
    105                     content: original.content,
    106                     tags: original.tags,
    107                     created_at: original.created_at,
    108                     kind: original.kind,
    109                     pubkey: original.pubkey,
    110                     id: original.id,
    111                     observation: { fixture: true }
    112                   }
    113                 : { ...original };
    114             if (readMode === 'wrong_id') event.id = 'f'.repeat(64);
    115             if (readMode === 'wrong_sig') {
    116               event.sig = '0'.repeat(128);
    117               event.verified = true;
    118             }
    119             if (readMode === 'wrong_recipient')
    120               event.tags = [['p', 'f'.repeat(64)]];
    121             if (readMode === 'wrong_content')
    122               event.content = String(event.content) + 'a';
    123             if (readMode === 'oversized' || readMode === 'flood_bytes')
    124               event.content = 'x'.repeat(
    125                 readMode === 'oversized' ? 40000 : 31000
    126               );
    127             if (readMode === 'flood_deliveries')
    128               event.content = String(event.content) + 'a';
    129             let wire = JSON.stringify(['EVENT', frame[1], event]);
    130             if (readMode === 'sdk_duplicate')
    131               wire = wire.replace('"kind":1059', '"kind":1059,"kind":1059');
    132             if (readMode === 'sdk_numeric_alias')
    133               wire = wire.replace('"kind":1059', '"kind":1.059e3');
    134             for (let n = 0; n < (readMode.startsWith('flood_') ? 501 : 1); n++)
    135               socket.send(wire);
    136           }
    137         }
    138         socket.send(JSON.stringify(['EOSE', frame[1]]));
    139       } else if (frame[0] === 'AUTH') {
    140         socket.send(
    141           JSON.stringify(['OK', (frame[1] as { id: string }).id, true, ''])
    142         );
    143       } else if (frame[0] === 'EVENT' && response !== 'unknown') {
    144         archived.set(
    145           (frame[1] as { id: string }).id,
    146           frame[1] as Record<string, unknown>
    147         );
    148         socket.send(
    149           JSON.stringify([
    150             'OK',
    151             response === 'wrong'
    152               ? 'f'.repeat(64)
    153               : (frame[1] as { id: string }).id,
    154             response !== 'refused' && response !== 'auth_required',
    155             response === 'auth_required'
    156               ? 'auth-required: source fixture'
    157               : response === 'refused'
    158                 ? 'blocked: source fixture'
    159                 : ''
    160           ])
    161         );
    162       }
    163     });
    164   });
    165   const result = await build({
    166     configFile: false,
    167     logLevel: 'silent',
    168     build: {
    169       write: false,
    170       minify: false,
    171       lib: {
    172         entry: fileURLToPath(
    173           new URL('./harness/inbox-probe-nonce.ts', import.meta.url)
    174         ),
    175         name: 'nc',
    176         formats: ['iife']
    177       }
    178     }
    179   });
    180   const output = Array.isArray(result) ? result[0] : result;
    181   if (!('output' in output)) throw Error('compiled fixture');
    182   const chunks = output.output.filter((x) => x.type === 'chunk');
    183   expect(chunks).toHaveLength(1);
    184   bundle = chunks[0].code;
    185 });
    186 test.afterAll(async () => {
    187   for (const socket of sockets.clients) socket.terminate();
    188   await new Promise<void>((resolve) => sockets.close(() => resolve()));
    189   await server.close();
    190 });
    191 test.beforeEach(async ({ page }, testInfo) => {
    192   await expect.poll(() => physical.size).toBe(0);
    193   head = '';
    194   readMode = 'exact';
    195   archived.clear();
    196   response = 'accepted';
    197   auth = false;
    198   peak = 0;
    199   privatePeak = 0;
    200   privateConnections.clear();
    201   frames.length = 0;
    202   await page.addInitScript(
    203     ({ endpoint }) => {
    204       const Native = window.WebSocket;
    205       window.WebSocket = class extends Native {
    206         constructor(url: string | URL, protocols?: string | string[]) {
    207           const origin = new URL(String(url)).origin;
    208           if (
    209             ![
    210               'wss://discovery.example.org',
    211               'wss://inbox.example.org',
    212               'wss://peer.example.org',
    213               'wss://archive.example.org'
    214             ].includes(origin)
    215           )
    216             throw Error('unapproved fixture origin');
    217           super(endpoint + '/?origin=' + encodeURIComponent(origin), protocols);
    218           if (
    219             origin === 'wss://inbox.example.org' &&
    220             window.ncAdvanceOnSocket
    221           ) {
    222             if (window.ncAdvanceOnSocket === 'network')
    223               window.ncNetworkClock!.advance(45001);
    224             else window.ncAdvancePage!();
    225           }
    226           if (
    227             window.ncInvalidateOnSocket &&
    228             origin === 'wss://inbox.example.org'
    229           )
    230             window.nc.closeInboxAccessController(
    231               window.ncFixture.controller()!
    232             );
    233         }
    234         override close(code?: number, reason?: string) {
    235           if (window.ncFailClose)
    236             throw Error('actual controlled disposal failure');
    237           if (window.ncDelayClose)
    238             (window.ncHeldClose ??= []).push(() => super.close(code, reason));
    239           else super.close(code, reason);
    240         }
    241       };
    242     },
    243     { endpoint }
    244   );
    245   await page.goto(server.url + '/search');
    246   await page.addScriptTag({ content: bundle });
    247   head = await page.evaluate(async (multi) => {
    248     window.ncFixture = await window.nc.makeNonceFixture();
    249     return window.ncFixture.preferenceWire(
    250       multi
    251         ? [
    252             'wss://inbox.example.org',
    253             'wss://peer.example.org',
    254             'wss://archive.example.org'
    255           ]
    256         : ['wss://inbox.example.org']
    257     );
    258   }, testInfo.title.includes('three-origin'));
    259   await page.evaluate(async () => {
    260     const f = window.ncFixture;
    261     await f.capture();
    262     if (
    263       (await f.reserve()).status !== 'reserved' ||
    264       (await f.prepare()) !== 'wrapped' ||
    265       (await f.commitOriginal()).status !== 'prepared'
    266     )
    267       throw Error('genuine cold native original setup');
    268   });
    269 });
    270 test.afterEach(async ({ page }) => {
    271   if (!page.isClosed())
    272     await page.evaluate(() => {
    273       window.ncRestore?.();
    274       window.ncFailClose = false;
    275       window.ncDelayClose = false;
    276       for (const release of window.ncHeldClose ?? []) release();
    277       window.ncFixture.close();
    278     });
    279 });
    280 function privateEvents() {
    281   return frames.filter(
    282     (x) => x.origin !== 'wss://discovery.example.org' && x.frame[0] === 'EVENT'
    283   );
    284 }
    285 function privateReads() {
    286   return frames.filter(
    287     (x) => x.origin !== 'wss://discovery.example.org' && x.frame[0] === 'REQ'
    288   );
    289 }
    290 
    291 async function publishOriginal(page: import('@playwright/test').Page) {
    292   return page.evaluate(async () => {
    293     const f = window.ncFixture,
    294       result = await f.publish();
    295     await f.append(result);
    296     return result;
    297   });
    298 }
    299 async function readOriginal(page: import('@playwright/test').Page) {
    300   await publishOriginal(page);
    301   expect(
    302     await page.evaluate(async () => {
    303       const f = window.ncFixture,
    304         result = await f.read();
    305       const saved = await f.appendRead(result);
    306       return { read: result.status, saved: saved.status };
    307     })
    308   ).toEqual({ read: 'readback', saved: 'saved' });
    309 }
    310 test('cold genuine B2 readback verifies original nonce by guarded SDK without an earlier ordinary send, plaintext exposure, row growth or extra traffic', async ({
    311   page
    312 }) => {
    313   await readOriginal(page);
    314   const observed = await page.evaluate(async () => {
    315     const f = window.ncFixture,
    316       rows = await f.stored(),
    317       before = f.counts(),
    318       first = f.nonceCapture()!,
    319       second = f.nonceCapture();
    320     const inert = f.counts();
    321     const receiver = f.decryptCallback(0, (x) => x);
    322     const result = await f.nonce(first),
    323       after = f.counts(),
    324       again = await f.nonce(first),
    325       binding = f.proofBinding();
    326     const copies = {
    327       reader: await window.nc.readInboxProbeNonce({ ...first }),
    328       proof: window.nc.inboxProbeNonceProofBinding(
    329         { ...result.proof! },
    330         f.repository,
    331         f.session,
    332         f.policy
    333       ),
    334       ordinary: window.nc.recoveredSelfEnvelopeSnapshot(
    335         result.proof! as unknown as Parameters<
    336           typeof window.nc.recoveredSelfEnvelopeSnapshot
    337         >[0]
    338       )
    339     };
    340     return {
    341       same: first === second,
    342       before,
    343       inert,
    344       after,
    345       result,
    346       again,
    347       binding: binding && {
    348         owner: binding.owner,
    349         command: binding.command,
    350         rumorHash: binding.rumorHash,
    351         eventId: binding.eventId,
    352         keys: Object.keys(binding)
    353       },
    354       sameProof: result.proof === again.proof,
    355       receivers: receiver.receivers(),
    356       rowsSame: JSON.stringify(rows) === JSON.stringify(await f.stored()),
    357       copies,
    358       readiness: window.nc.inboxAccessControllerSnapshot(f.controller()!)
    359         ?.readiness
    360     };
    361   });
    362   expect(observed.same).toBe(true);
    363   expect(observed.inert).toEqual(observed.before);
    364   expect(observed.result.status).toBe('nonce_verified');
    365   expect(observed.again.status).toBe('nonce_verified');
    366   expect(observed.sameProof).toBe(true);
    367   expect(observed.after.decrypts - observed.before.decrypts).toBe(2);
    368   expect(observed.after.keys - observed.before.keys).toBe(3);
    369   expect(observed.receivers).toBe(2);
    370   expect(observed.rowsSame).toBe(true);
    371   expect(observed.binding?.keys).not.toContain('rumorWire');
    372   expect(observed.binding?.keys).not.toContain('sealWire');
    373   expect(observed.binding?.keys).not.toContain('nonce');
    374   expect(observed.copies).toEqual({
    375     reader: { status: 'invalid' },
    376     proof: undefined,
    377     ordinary: undefined
    378   });
    379   expect(observed.readiness).toBe('unavailable');
    380   expect(privateEvents()).toHaveLength(1);
    381   expect(privateReads()).toHaveLength(1);
    382 });
    383 for (const review of [
    384   undefined,
    385   true,
    386   'reviewed_self_decryption',
    387   'reviewed_inbox_probe_commit'
    388 ])
    389   test(`nonce capture refuses wrong explicit review ${String(review)} without effects`, async ({
    390     page
    391   }) => {
    392     await readOriginal(page);
    393     expect(
    394       await page.evaluate((review) => {
    395         const f = window.ncFixture,
    396           before = f.counts();
    397         const reader = window.nc.captureInboxProbeNonceReader(
    398           f.repository,
    399           f.identity,
    400           f.session,
    401           f.policy,
    402           f.lastRead()!,
    403           review
    404         );
    405         return {
    406           captured: !!reader,
    407           unchanged: JSON.stringify(before) === JSON.stringify(f.counts())
    408         };
    409       }, review)
    410     ).toEqual({ captured: false, unchanged: true });
    411   });
    412 for (const fault of [
    413   'copy',
    414   'archive',
    415   'foreign_repository',
    416   'foreign_session',
    417   'copied_policy',
    418   'wrong_identity',
    419   'ordinary_family'
    420 ])
    421   test(`nonce admission rejects ${fault} original association`, async ({
    422     page
    423   }) => {
    424     await readOriginal(page);
    425     expect(
    426       await page.evaluate(async (fault) => {
    427         const f = window.ncFixture,
    428           before = f.counts();
    429         let identity = f.identity,
    430           session = f.session,
    431           repository = f.repository,
    432           policy = f.policy,
    433           observation = f.lastRead()!;
    434         if (fault === 'copy') observation = { ...observation };
    435         if (fault === 'archive')
    436           observation = f.last() as unknown as typeof observation;
    437         if (fault === 'foreign_repository') repository = f.foreignRepository();
    438         if (fault === 'foreign_session') session = await f.foreignSession();
    439         if (fault === 'copied_policy') policy = f.copiedPolicy();
    440         if (fault === 'wrong_identity')
    441           identity = window.nc.createIdentitySession();
    442         if (fault === 'ordinary_family')
    443           observation = {
    444             status: 'readback',
    445             eventId: f.snapshot()!.record.self!.eventId
    446           };
    447         const baseline = f.counts(),
    448           reader = window.nc.captureInboxProbeNonceReader(
    449             repository,
    450             identity,
    451             session,
    452             policy,
    453             observation,
    454             'reviewed_inbox_probe_nonce_decryption'
    455           );
    456         return {
    457           captured: !!reader,
    458           unchanged: JSON.stringify(baseline) === JSON.stringify(f.counts()),
    459           initial: !!before
    460         };
    461       }, fault)
    462     ).toEqual({ captured: false, unchanged: true, initial: true });
    463   });
    464 for (const fault of [
    465   'removed',
    466   'alias',
    467   'corrupt',
    468   'handwritten_fact',
    469   'corrupt_tail'
    470 ])
    471   test(`nonce initial native custody rejects ${fault} before SDK`, async ({
    472     page
    473   }) => {
    474     await readOriginal(page);
    475     const result = await page.evaluate(async (fault) => {
    476       const f = window.ncFixture,
    477         reader = f.nonceCapture()!,
    478         before = f.counts(),
    479         row = (await f.stored())[0];
    480       if (fault === 'removed') await f.removeOriginal();
    481       else if (fault === 'alias')
    482         await f.inject([{ ...row, wire: row.wire + '\n' }]);
    483       else if (fault === 'corrupt') await f.inject([{ ...row, wire: '{}' }]);
    484       else if (fault === 'handwritten_fact') await f.changedNativeFact();
    485       else
    486         await f.inject([
    487           { owner: f.owner, id: crypto.randomUUID(), wire: '{}' }
    488         ]);
    489       const result = await f.nonce(reader);
    490       return {
    491         status: result.status,
    492         unchanged: JSON.stringify(before) === JSON.stringify(f.counts()),
    493         proof: !!f.proofBinding()
    494       };
    495     }, fault);
    496     expect(result.status).not.toBe('nonce_verified');
    497     expect(result.unchanged).toBe(true);
    498     expect(result.proof).toBe(false);
    499   });
    500 for (const mode of [
    501   'wrong_key',
    502   'refuse_decrypt',
    503   'wrong_decrypt',
    504   'stop_decrypt_getter'
    505 ] as const)
    506   test(`actual provider ${mode} refuses nonce proof`, async ({ page }) => {
    507     await readOriginal(page);
    508     const result = await page.evaluate(async (mode) => {
    509       const f = window.ncFixture,
    510         reader = f.nonceCapture()!;
    511       f.mode(mode);
    512       const result = await f.nonce(reader);
    513       return { status: result.status, proof: !!f.proofBinding() };
    514     }, mode);
    515     expect(result.status).not.toBe('nonce_verified');
    516     expect(result.proof).toBe(false);
    517     expect(privateEvents()).toHaveLength(1);
    518     expect(privateReads()).toHaveLength(1);
    519   });
    520 for (const fault of [
    521   'outer_huge',
    522   'seal_signature',
    523   'seal_tags',
    524   'seal_kind',
    525   'rumor_owner',
    526   'rumor_time',
    527   'rumor_hash',
    528   'rumor_body',
    529   'rumor_huge',
    530   'rumor_serialization'
    531 ])
    532   test(`actual decrypted ${fault} cannot mint a nonce proof`, async ({
    533     page
    534   }) => {
    535     await readOriginal(page);
    536     const result = await page.evaluate(async (fault) => {
    537       const f = window.ncFixture,
    538         outer = fault.startsWith('outer') || fault.startsWith('seal');
    539       f.decryptCallback(outer ? 1 : 2, async (wire) => {
    540         if (fault.endsWith('huge')) return 'x'.repeat(outer ? 16385 : 8193);
    541         if (fault === 'rumor_serialization') return wire + '\n';
    542         if (fault === 'seal_tags')
    543           return f.signSeal(wire, { tags: [['p', f.owner]] });
    544         if (fault === 'seal_kind') return f.signSeal(wire, { kind: 14 });
    545         const parsed = JSON.parse(wire) as Record<string, unknown>;
    546         if (fault === 'seal_signature') {
    547           parsed.sig = '0'.repeat(128);
    548           parsed.verified = true;
    549         }
    550         if (fault === 'rumor_owner') parsed.pubkey = 'f'.repeat(64);
    551         if (fault === 'rumor_time')
    552           parsed.created_at = Number(parsed.created_at) + 1;
    553         if (fault === 'rumor_hash') parsed.id = 'f'.repeat(64);
    554         if (fault === 'rumor_body')
    555           parsed.content =
    556             'Harvestcircle private inbox access check v1: ' + '0'.repeat(64);
    557         return JSON.stringify(parsed);
    558       });
    559       const result = await f.nonce();
    560       return { status: result.status, proof: !!f.proofBinding() };
    561     }, fault);
    562     expect(result.status).toBe('mismatch');
    563     expect(result.proof).toBe(false);
    564   });
    565 for (const stage of [1, 2, 3])
    566   for (const fault of ['head', 'controller', 'session', 'native'])
    567     test(`actual key ${stage} ${fault} churn prevents nonce proof`, async ({
    568       page
    569     }) => {
    570       await readOriginal(page);
    571       const result = await page.evaluate(
    572         async ({ stage, fault }) => {
    573           const f = window.ncFixture,
    574             reader = f.nonceCapture()!;
    575           f.keyCallback(stage, async () => {
    576             if (fault === 'head') f.churnHead();
    577             else if (fault === 'controller')
    578               window.nc.closeInboxAccessController(f.controller()!);
    579             else if (fault === 'session') f.closeSession();
    580             else await f.changedNativeFact();
    581           });
    582           const result = await f.nonce(reader);
    583           return { status: result.status, proof: !!f.proofBinding() };
    584         },
    585         { stage, fault }
    586       );
    587       expect(result.status).not.toBe('nonce_verified');
    588       expect(result.proof).toBe(false);
    589     });
    590 test('actual cipher getter currentness loss cannot call captured decrypt method', async ({
    591   page
    592 }) => {
    593   await readOriginal(page);
    594   const result = await page.evaluate(async () => {
    595     const f = window.ncFixture,
    596       reader = f.nonceCapture()!,
    597       before = f.counts();
    598     f.cipherGetter(() => f.churnHead());
    599     const result = await f.nonce(reader);
    600     return {
    601       status: result.status,
    602       calls: f.counts().decrypts - before.decrypts,
    603       proof: !!f.proofBinding(),
    604       identityCurrent: !!window.nc
    605         .identityMessagingOwnership(f.identity)
    606         ?.current(),
    607       privateCurrent: !!window.nc.privateSessionOwnership(f.session)?.current()
    608     };
    609   });
    610   expect(result).toEqual({
    611     status: 'stopped',
    612     calls: 0,
    613     proof: false,
    614     identityCurrent: true,
    615     privateCurrent: true
    616   });
    617 });
    618 for (const stop of ['stop', 'expire', 'head', 'controller', 'session'])
    619   test(`pending real SDK decrypt ${stop} retains original slot and refuses late proof`, async ({
    620     page
    621   }) => {
    622     await readOriginal(page);
    623     await page.evaluate(() => {
    624       const f = window.ncFixture;
    625       f.mode('hold_decrypt');
    626       window.ncNoncePending = f.nonce();
    627     });
    628     await expect
    629       .poll(() => page.evaluate(() => window.ncFixture.waiting()))
    630       .toBe('decrypt');
    631     const pending = await page.evaluate(async (stop) => {
    632       const f = window.ncFixture,
    633         reader = f.nonceReader()!;
    634       if (stop === 'stop') window.nc.stopInboxProbeNonceReader(reader);
    635       else if (stop === 'expire')
    636         window.nc.expireInboxProbeNonceReaderWait(reader);
    637       else if (stop === 'head') f.churnHead();
    638       else if (stop === 'controller')
    639         window.nc.closeInboxAccessController(f.controller()!);
    640       else f.closeSession();
    641       const slot = window.nc.browserExtensionScheduler()!,
    642         before = window.nc.extensionSchedulerSnapshot(slot),
    643         another = await window.nc.runExtensionAction(
    644           slot,
    645           { owner: f.owner, session: Symbol(), operation: Symbol() },
    646           () => true,
    647           () => Promise.resolve('bad')
    648         );
    649       const proof = !!f.proofBinding();
    650       f.settle();
    651       return { before, another, proof };
    652     }, stop);
    653     expect(pending.before).toMatchObject({
    654       state: 'active',
    655       pending: 'decrypt'
    656     });
    657     expect(pending.another).toEqual({ status: 'busy' });
    658     expect(pending.proof).toBe(false);
    659     expect(
    660       await page.evaluate(async () => {
    661         await window.ncNoncePending;
    662         return {
    663           proof: !!window.ncFixture.proofBinding(),
    664           slot: window.nc.extensionSchedulerSnapshot(
    665             window.nc.browserExtensionScheduler()!
    666           )
    667         };
    668       })
    669     ).toEqual({ proof: false, slot: { state: 'idle' } });
    670   });
    671 for (const stop of [
    672   'stop',
    673   'expire',
    674   'head',
    675   'controller',
    676   'session',
    677   'identity'
    678 ])
    679   test(`genuine memory proof revokes on ${stop} without persisted nonce label or cleanup`, async ({
    680     page
    681   }) => {
    682     await readOriginal(page);
    683     const result = await page.evaluate(async (stop) => {
    684       const f = window.ncFixture;
    685       const rows = await f.stored();
    686       await f.nonce();
    687       const before = !!f.proofBinding();
    688       if (stop === 'stop')
    689         window.nc.stopInboxProbeNonceReader(f.nonceReader()!);
    690       else if (stop === 'expire')
    691         window.nc.expireInboxProbeNonceReaderWait(f.nonceReader()!);
    692       else if (stop === 'head') f.churnHead();
    693       else if (stop === 'controller')
    694         window.nc.closeInboxAccessController(f.controller()!);
    695       else if (stop === 'identity') window.nc.disconnectIdentity(f.identity);
    696       else f.closeSession();
    697       return {
    698         before,
    699         after: !!f.proofBinding(),
    700         retained: JSON.stringify(rows) === JSON.stringify(await f.stored())
    701       };
    702     }, stop);
    703     expect(result).toEqual({ before: true, after: false, retained: true });
    704   });
    705 test('parallel and callback reentry share original observation reader and never start another SDK action', async ({
    706   page
    707 }) => {
    708   await readOriginal(page);
    709   await page.evaluate(() => {
    710     const f = window.ncFixture;
    711     const original = f.nonceCapture()!;
    712     f.keyCallback(1, () => {
    713       if (f.nonceCapture() !== original)
    714         throw Error('reentrant reader changed');
    715       window.ncNonceOther = window.nc.readInboxProbeNonce(original);
    716     });
    717     f.mode('hold_decrypt');
    718     window.ncNoncePending = f.nonce(original);
    719   });
    720   await expect
    721     .poll(() => page.evaluate(() => window.ncFixture.waiting()))
    722     .toBe('decrypt');
    723   expect(
    724     await page.evaluate(async () => {
    725       const f = window.ncFixture,
    726         other = await window.ncNonceOther,
    727         parallel = await window.nc.readInboxProbeNonce(f.nonceReader()!);
    728       f.mode('normal');
    729       f.settle();
    730       return { other, parallel };
    731     })
    732   ).toEqual({ other: { status: 'busy' }, parallel: { status: 'busy' } });
    733   expect(
    734     await page.evaluate(async () => {
    735       const result = (await window.ncNoncePending) as { status: string };
    736       return result.status;
    737     })
    738   ).toBe('nonce_verified');
    739 });
    740 
    741 test('genuine ordinary and nonce reader brands cannot cross and ordinary probe-row reading remains invalid_scope', async ({
    742   page
    743 }) => {
    744   await readOriginal(page);
    745   const result = await page.evaluate(async () => {
    746     const f = window.ncFixture,
    747       nonce = f.nonceCapture()!,
    748       ordinary = window.nc.captureSelfRecoveryReader(
    749         f.repository,
    750         f.identity,
    751         f.snapshot()!.record.id,
    752         'reviewed_self_decryption'
    753       )!;
    754     const before = f.counts();
    755     const nonceFromOrdinary = await window.nc.readInboxProbeNonce(
    756         ordinary as unknown as Parameters<
    757           typeof window.nc.readInboxProbeNonce
    758         >[0]
    759       ),
    760       ordinaryFromNonce = await window.nc.readSelfRecoveryEnvelope(
    761         nonce as unknown as Parameters<
    762           typeof window.nc.readSelfRecoveryEnvelope
    763         >[0]
    764       ),
    765       originalOrdinary = await window.nc.readSelfRecoveryEnvelope(ordinary);
    766     return {
    767       genuine: !!ordinary && !!nonce,
    768       nonceFromOrdinary,
    769       ordinaryFromNonce,
    770       originalOrdinary,
    771       unchanged: JSON.stringify(before) === JSON.stringify(f.counts())
    772     };
    773   });
    774   expect(result).toEqual({
    775     genuine: true,
    776     nonceFromOrdinary: { status: 'invalid' },
    777     ordinaryFromNonce: { status: 'invalid' },
    778     originalOrdinary: { status: 'invalid_scope' },
    779     unchanged: true
    780   });
    781 });
    782 test('forged read result cannot retry cleanup of a genuine closed private session', async ({
    783   page
    784 }) => {
    785   await readOriginal(page);
    786   expect(
    787     await page.evaluate(() => {
    788       const f = window.ncFixture;
    789       let retries = 0;
    790       const off = window.nc.subscribePrivateSessionClose(f.session, () => {
    791         retries++;
    792         throw Error('controlled retained original cleanup');
    793       });
    794       f.closeSession();
    795       const before = retries;
    796       const reader = window.nc.captureInboxProbeNonceReader(
    797         f.repository,
    798         f.identity,
    799         f.session,
    800         f.policy,
    801         { status: 'readback' },
    802         'reviewed_inbox_probe_nonce_decryption'
    803       );
    804       const after = retries,
    805         cleanup = window.nc.privateSessionCleanupRequired(f.session);
    806       off();
    807       return { captured: !!reader, unchanged: before === after, cleanup };
    808     })
    809   ).toEqual({ captured: false, unchanged: true, cleanup: true });
    810 });
    811 for (const fault of [
    812   'provider',
    813   'key_method',
    814   'cipher',
    815   'decrypt_method',
    816   'throw_cipher',
    817   'cipher_version'
    818 ])
    819   test(`missing or invalid actual ${fault} never authorizes nonce proof`, async ({
    820     page
    821   }) => {
    822     await readOriginal(page);
    823     const result = await page.evaluate(async (fault) => {
    824       const f = window.ncFixture,
    825         reader = f.nonceCapture()!,
    826         provider = Reflect.get(window, 'nostr') as {
    827           getPublicKey(): Promise<string>;
    828           nip44: { decrypt(target: string, content: string): Promise<string> };
    829         },
    830         descriptor = Object.getOwnPropertyDescriptor(window, 'nostr')!;
    831       const cipher = provider.nip44,
    832         cipherDescriptor = Object.getOwnPropertyDescriptor(provider, 'nip44')!,
    833         keyDescriptor = Object.getOwnPropertyDescriptor(
    834           provider,
    835           'getPublicKey'
    836         )!,
    837         decryptDescriptor = Object.getOwnPropertyDescriptor(cipher, 'decrypt')!;
    838       try {
    839         if (fault === 'provider')
    840           Object.defineProperty(window, 'nostr', {
    841             configurable: true,
    842             value: undefined
    843           });
    844         else if (fault === 'key_method')
    845           Object.defineProperty(provider, 'getPublicKey', {
    846             configurable: true,
    847             value: undefined
    848           });
    849         else if (fault === 'cipher')
    850           Object.defineProperty(provider, 'nip44', {
    851             configurable: true,
    852             value: undefined
    853           });
    854         else if (fault === 'decrypt_method')
    855           Object.defineProperty(cipher, 'decrypt', {
    856             configurable: true,
    857             value: undefined
    858           });
    859         else if (fault === 'throw_cipher')
    860           Object.defineProperty(provider, 'nip44', {
    861             configurable: true,
    862             get() {
    863               throw Error('controlled actual capability getter');
    864             }
    865           });
    866         else
    867           f.decryptCallback(1, (wire) =>
    868             f.signSeal(wire, { content: 'not NIP44v2' })
    869           );
    870         const result = await f.nonce(reader);
    871         return { status: result.status, proof: !!f.proofBinding() };
    872       } finally {
    873         Object.defineProperty(window, 'nostr', descriptor);
    874         Object.defineProperty(provider, 'nip44', cipherDescriptor);
    875         Object.defineProperty(provider, 'getPublicKey', keyDescriptor);
    876         Object.defineProperty(cipher, 'decrypt', decryptDescriptor);
    877       }
    878     }, fault);
    879     expect(result.status).not.toBe('nonce_verified');
    880     expect(result.proof).toBe(false);
    881   });
    882 test('same-owner replacement genuine identity has no original private session nonce admission', async ({
    883   page
    884 }) => {
    885   await readOriginal(page);
    886   expect(
    887     await page.evaluate(async () => {
    888       const f = window.ncFixture,
    889         replacement = window.nc.createIdentitySession();
    890       await window.nc.connectIdentity(replacement);
    891       await window.nc.probeIdentityMessaging(replacement, 'reviewed_self_copy');
    892       const sameOwner =
    893           window.nc.identityMessagingOwnership(replacement)?.owner === f.owner,
    894         before = f.counts();
    895       const reader = window.nc.captureInboxProbeNonceReader(
    896         f.repository,
    897         replacement,
    898         f.session,
    899         f.policy,
    900         f.lastRead()!,
    901         'reviewed_inbox_probe_nonce_decryption'
    902       );
    903       const unchanged = JSON.stringify(before) === JSON.stringify(f.counts());
    904       window.nc.disconnectIdentity(replacement);
    905       return { captured: !!reader, sameOwner, unchanged };
    906     })
    907   ).toEqual({ captured: false, sameOwner: true, unchanged: true });
    908 });
    909 for (const hit of [1, 2])
    910   test(`actual native readonly abort ${hit} refuses nonce proof`, async ({
    911     page
    912   }) => {
    913     await readOriginal(page);
    914     const result = await page.evaluate(async (hit) => {
    915       const f = window.ncFixture,
    916         reader = f.nonceCapture()!,
    917         original = Object.getOwnPropertyDescriptor(
    918           IDBDatabase.prototype,
    919           'transaction'
    920         )!.value as IDBDatabase['transaction'];
    921       let reads = 0,
    922         aborted = 0;
    923       IDBDatabase.prototype.transaction = function (
    924         ...args: Parameters<IDBDatabase['transaction']>
    925       ) {
    926         const tx = original.apply(this, args);
    927         if (
    928           args[1] === 'readonly' &&
    929           tx.objectStoreNames.contains('private_sends') &&
    930           ++reads === hit
    931         ) {
    932           aborted++;
    933           queueMicrotask(() => tx.abort());
    934         }
    935         return tx;
    936       };
    937       try {
    938         const result = await f.nonce(reader);
    939         return { status: result.status, proof: !!f.proofBinding(), aborted };
    940       } finally {
    941         IDBDatabase.prototype.transaction = original;
    942       }
    943     }, hit);
    944     expect(result.status).not.toBe('nonce_verified');
    945     expect(result.proof).toBe(false);
    946     expect(result.aborted).toBe(1);
    947   });
    948 test('actual occupied owner lock prevents SDK nonce work', async ({ page }) => {
    949   await readOriginal(page);
    950   expect(
    951     await page.evaluate(async () => {
    952       const f = window.ncFixture,
    953         reader = f.nonceCapture()!;
    954       let entered: (() => void) | undefined, release: (() => void) | undefined;
    955       const ready = new Promise<void>((resolve) => {
    956         entered = resolve;
    957       });
    958       const held = navigator.locks.request(
    959         'harvestcircle:owner:' + f.owner,
    960         async () => {
    961           entered?.();
    962           await new Promise<void>((resolve) => {
    963             release = resolve;
    964           });
    965         }
    966       );
    967       await ready;
    968       const before = f.counts();
    969       try {
    970         const result = await f.nonce(reader);
    971         return {
    972           status: result.status,
    973           unchanged: JSON.stringify(before) === JSON.stringify(f.counts())
    974         };
    975       } finally {
    976         release?.();
    977         await held;
    978       }
    979     })
    980   ).toEqual({ status: 'busy', unchanged: true });
    981 });
    982 for (const fault of ['wrong', 'denied'])
    983   test(`actual ${fault} key refuses before any cipher getter acquisition`, async ({
    984     page
    985   }) => {
    986     await readOriginal(page);
    987     expect(
    988       await page.evaluate(async (fault) => {
    989         const f = window.ncFixture,
    990           reader = f.nonceCapture()!;
    991         let getters = 0;
    992         f.cipherGetter(() => {
    993           getters++;
    994         });
    995         if (fault === 'wrong') f.mode('wrong_key');
    996         else
    997           f.keyCallback(1, () => {
    998             throw Error('actual controlled key refusal');
    999           });
   1000         const before = f.counts(),
   1001           result = await f.nonce(reader);
   1002         return {
   1003           status: result.status,
   1004           getters,
   1005           decrypts: f.counts().decrypts - before.decrypts,
   1006           identityCurrent: !!window.nc
   1007             .identityMessagingOwnership(f.identity)
   1008             ?.current()
   1009         };
   1010       }, fault)
   1011     ).toEqual({
   1012       status: 'stopped',
   1013       getters: 0,
   1014       decrypts: 0,
   1015       identityCurrent: false
   1016     });
   1017   });