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 });