private-pool.test.ts (32030B)
1 import { test } from 'node:test'; 2 import assert from 'node:assert/strict'; 3 import { once } from 'node:events'; 4 import WebSocket, { WebSocketServer } from 'ws'; 5 import { RelayPool } from 'applesauce-relay/pool'; 6 import { createRequire } from 'node:module'; 7 import { validateRelayPolicy } from '../../src/lib/config/relays.ts'; 8 import { 9 createIdentitySession, 10 connectIdentity, 11 probeIdentityMessaging, 12 disconnectIdentity, 13 recheckIdentityOwner 14 } from '../../src/lib/runtime/identity-session.ts'; 15 import { 16 createPrivateSession, 17 privateSessionSnapshot, 18 closePrivateSession 19 } from '../../src/lib/runtime/private-session.ts'; 20 import { 21 getPrivatePool, 22 privatePoolOrigins, 23 subscribePrivatePage, 24 closePrivatePool, 25 privatePoolCleanupRequired, 26 type PrivatePageMessage 27 } from '../../src/lib/nostr/private-pool.ts'; 28 import { 29 getPublicPool, 30 subscribePublicPool, 31 closePublicPool 32 } from '../../src/lib/nostr/public-pool.ts'; 33 34 // HC_TEST_ONLY_RELAY/provider: genuine pinned SDK, fixed logical origins mapped 35 // solely here to loopback. Echo cipher and AUTH-state instrumentation qualify 36 // transport/lifecycle isolation, never encryption, signatures or relay access. 37 await test('private page transport keeps actual SDK scopes and ownership separate', async (t) => { 38 // Resolve the SDK's actual pinned transitive RxJS for teardown fault injection; 39 // it is not a new application dependency or replacement Observable. 40 const sdkRxjs: unknown = createRequire( 41 import.meta.resolve('applesauce-relay/pool') 42 )('rxjs'); 43 const Subscription = ( 44 sdkRxjs as { 45 Subscription: { 46 prototype: ReturnType<ReturnType<RelayPool['req']>['subscribe']>; 47 }; 48 } 49 ).Subscription; 50 const owner = 51 '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'; 52 const other = 53 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5'; 54 const origins = [ 55 'wss://relay.example.org', 56 'wss://relay-two.example.org', 57 'wss://relay-three.example.org' 58 ]; 59 const policy = validateRelayPolicy( 60 JSON.stringify({ 61 schemaVersion: 1, 62 public: origins.map((origin) => ({ 63 origin, 64 read: true, 65 write: false, 66 nip50: false 67 })), 68 inbox: origins.map((origin) => ({ origin, read: true, write: true })), 69 postingEnabled: false, 70 messagingEnabled: true, 71 operatorDenylist: [] 72 }) 73 ); 74 assert.ok(policy); 75 assert.equal( 76 await createPrivateSession( 77 createIdentitySession(), 78 'reviewed_private_session' 79 ), 80 undefined 81 ); 82 assert.equal(getPrivatePool({} as never, policy, origins), undefined); 83 const originalSocket = globalThis.WebSocket, 84 originalFetch = globalThis.fetch, 85 originalReq = Reflect.get(RelayPool.prototype, 'req'), 86 originalClose = Reflect.get(RelayPool.prototype, 'close'); 87 assert.equal( 88 Object.getOwnPropertyDescriptor(globalThis, 'window'), 89 undefined 90 ); 91 const server = new WebSocketServer({ 92 host: '127.0.0.1', 93 port: 0, 94 maxPayload: 65536 95 }); 96 const sockets: WebSocket[] = []; 97 const frames: unknown[][] = []; 98 let delivery: 99 | 'normal' 100 | 'flood' 101 | 'oversize' 102 | 'hold' 103 | 'byte-flood' 104 | 'rejected-byte-flood' 105 | 'single' = 'normal'; 106 let eventWritten = false; 107 let heldReady = () => {}; 108 let heldRequests = 0; 109 const raw = { 110 id: '1'.repeat(64), 111 pubkey: other, 112 kind: 1059, 113 created_at: 1, 114 tags: [['p', owner]], 115 content: 'untrusted ciphertext', 116 sig: '0'.repeat(128) 117 }; 118 server.on('connection', (socket) => { 119 sockets.push(socket); 120 socket.send(JSON.stringify(['AUTH', 'unsolicited-challenge'])); 121 socket.on('message', (bytes) => { 122 const buffer = Array.isArray(bytes) 123 ? Buffer.concat(bytes) 124 : Buffer.isBuffer(bytes) 125 ? bytes 126 : Buffer.from(bytes); 127 const frame: unknown = JSON.parse(buffer.toString('utf8')); 128 assert.ok(Array.isArray(frame)); 129 frames.push(frame); 130 if (frame[0] !== 'REQ') return; 131 const filter = frame[2] as { kinds: number[] }; 132 if (filter.kinds[0] === 1059 && delivery === 'hold') { 133 heldRequests++; 134 if (heldRequests === 3) heldReady(); 135 } else if ( 136 filter.kinds[0] === 1059 && 137 (delivery === 'flood' || 138 delivery === 'byte-flood' || 139 delivery === 'rejected-byte-flood') 140 ) { 141 const candidate = 142 delivery === 'flood' 143 ? raw 144 : { 145 ...raw, 146 content: 'x'.repeat(delivery === 'byte-flood' ? 20000 : 40000) 147 }; 148 for (let i = 0; i < 501; i++) 149 socket.send(JSON.stringify(['EVENT', frame[1], candidate])); 150 } else if (filter.kinds[0] === 1059 && delivery === 'single') { 151 eventWritten = true; 152 socket.send(JSON.stringify(['EVENT', frame[1], raw])); 153 socket.send(JSON.stringify(['EOSE', frame[1]])); 154 } else if (filter.kinds[0] === 1059 && delivery === 'oversize') { 155 socket.send( 156 JSON.stringify([ 157 'EVENT', 158 frame[1], 159 { ...raw, content: 'x'.repeat(32768) } 160 ]) 161 ); 162 socket.send(JSON.stringify(['EOSE', frame[1]])); 163 } else socket.send(JSON.stringify(['EOSE', frame[1]])); 164 }); 165 }); 166 await once(server, 'listening'); 167 const address = server.address(); 168 assert.ok(address && typeof address !== 'string'); 169 const fixturePort = address.port; 170 let key = owner, 171 calls = 0, 172 signs = 0, 173 constructed = 0; 174 class FixtureSocket extends WebSocket { 175 constructor(url: string | URL) { 176 assert.ok(origins.includes(new URL(String(url)).origin)); 177 constructed++; 178 super(`ws://127.0.0.1:${fixturePort}`); 179 } 180 } 181 Object.defineProperty(globalThis, 'window', { 182 configurable: true, 183 value: { 184 nostr: { 185 getPublicKey: () => { 186 calls++; 187 return Promise.resolve(key); 188 }, 189 signEvent: () => { 190 signs++; 191 return Promise.reject(new Error('Unexpected signer')); 192 }, 193 nip44: { 194 encrypt: (_peer: string, text: string) => 195 Promise.resolve('fixture:' + text), 196 decrypt: (_peer: string, text: string) => 197 Promise.resolve(text.slice(8)) 198 } 199 } 200 } 201 }); 202 globalThis.WebSocket = 203 FixtureSocket as unknown as typeof globalThis.WebSocket; 204 globalThis.fetch = () => 205 Promise.reject(new Error('Unexpected information fetch')); 206 const sdkScopes = new Map<'public' | 'private', RelayPool>(); 207 const allScopes = new Set<RelayPool>(); 208 let requestCalls = 0; 209 RelayPool.prototype.req = function (relays, filters, options) { 210 requestCalls++; 211 allScopes.add(this); 212 assert.ok(Array.isArray(filters)); 213 const filter = filters[0] as { kinds: number[] }; 214 sdkScopes.set(filter.kinds[0] === 1059 ? 'private' : 'public', this); 215 return originalReq.call(this, relays, filters, options); 216 }; 217 const identity = createIdentitySession(); 218 let privateSession: Awaited<ReturnType<typeof createPrivateSession>>; 219 let privatePool: ReturnType<typeof getPrivatePool>; 220 let publicPool: ReturnType<typeof getPublicPool>; 221 const stops: Array<() => void> = []; 222 function publicPage() { 223 return new Promise<void>((resolve) => { 224 const seen = new Set<string>(); 225 stops.push( 226 subscribePublicPool( 227 publicPool!, 228 [{ kinds: [30402], limit: 1 }], 229 (message) => { 230 if (message.type === 'EOSE') { 231 seen.add(message.from); 232 if (seen.size === 3) resolve(); 233 } 234 } 235 ) 236 ); 237 }); 238 } 239 async function awaitRetirement() { 240 while (privatePool && privatePoolCleanupRequired(privatePool)) { 241 if (privateSessionSnapshot(privateSession!)?.current === false) 242 closePrivateSession(privateSession!); 243 await new Promise<void>((resolve) => setImmediate(resolve)); 244 } 245 } 246 async function heldPage() { 247 delivery = 'hold'; 248 heldRequests = 0; 249 const ready = new Promise<void>((resolve) => { 250 heldReady = resolve; 251 }); 252 stops.push(subscribePrivatePage(privatePool!, 200, () => {})); 253 await ready; 254 } 255 try { 256 await t.test( 257 'guest, forged and unreviewed session cannot acquire sockets', 258 async () => { 259 assert.equal( 260 await createPrivateSession(identity, 'unreviewed'), 261 undefined 262 ); 263 assert.equal( 264 await createPrivateSession(identity, 'reviewed_private_session'), 265 undefined 266 ); 267 assert.throws( 268 () => getPrivatePool({} as never, policy, origins), 269 /private_session_invalid/ 270 ); 271 assert.equal(constructed, 0); 272 assert.equal(calls, 0); 273 } 274 ); 275 await connectIdentity(identity); 276 await probeIdentityMessaging(identity, 'reviewed_self_copy'); 277 await t.test( 278 'explicit admission rechecks the genuine owner through the shared SDK', 279 async () => { 280 const before = calls; 281 privateSession = await createPrivateSession( 282 identity, 283 'reviewed_private_session' 284 ); 285 assert.ok(privateSession); 286 assert.equal(calls, before + 1); 287 assert.deepEqual(Object.keys(privateSession), []); 288 assert.ok(Object.isFrozen(privateSession)); 289 assert.deepEqual(privateSessionSnapshot(privateSession), { 290 owner, 291 current: true 292 }); 293 assert.equal(constructed, 0); 294 } 295 ); 296 await t.test( 297 'selection refuses hints, duplicates and oversized destination sets before egress', 298 () => { 299 assert.throws( 300 () => 301 getPrivatePool(privateSession!, policy, [ 302 ...origins, 303 'wss://unapproved.example.org' 304 ]), 305 /private_pool_origins_invalid/ 306 ); 307 assert.throws( 308 () => 309 getPrivatePool(privateSession!, policy, [ 310 'wss://unapproved.example.org' 311 ]), 312 /private_pool_origins_invalid/ 313 ); 314 assert.throws( 315 () => 316 getPrivatePool(privateSession!, policy, [origins[0], origins[0]]), 317 /private_pool_origins_invalid/ 318 ); 319 const selected = [...origins]; 320 let reentrant: ReturnType<typeof getPrivatePool>; 321 Object.defineProperty(selected, '0', { 322 configurable: true, 323 get: () => { 324 reentrant = getPrivatePool(privateSession!, policy, origins); 325 return origins[0]; 326 } 327 }); 328 privatePool = getPrivatePool(privateSession!, policy, selected); 329 assert.ok(privatePool); 330 assert.equal(privatePool, reentrant); 331 Object.defineProperty(selected, '0', { 332 configurable: true, 333 writable: true, 334 value: origins[0] 335 }); 336 selected[0] = 'wss://unapproved.example.org'; 337 const detached = privatePoolOrigins(privatePool) as string[]; 338 detached.push('wss://unapproved.example.org'); 339 assert.deepEqual(privatePoolOrigins(privatePool), origins); 340 assert.equal( 341 getPrivatePool(privateSession!, policy, origins), 342 privatePool 343 ); 344 assert.throws( 345 () => subscribePrivatePage(privatePool!, 201, () => {}), 346 /private_page_limit_invalid/ 347 ); 348 assert.equal(constructed, 0); 349 } 350 ); 351 await t.test( 352 'three public and three private same-origin sockets have separate AUTH state', 353 async () => { 354 publicPool = getPublicPool(policy); 355 assert.ok(publicPool); 356 await publicPage(); 357 await heldPage(); 358 assert.equal(constructed, 6); 359 assert.equal(server.clients.size, 6); 360 const pub = sdkScopes.get('public'), 361 priv = sdkScopes.get('private'); 362 assert.ok(pub && priv); 363 assert.notEqual(pub, priv); 364 for (const origin of origins) { 365 const a = pub.relay(origin), 366 b = priv.relay(origin); 367 assert.notEqual(a, b); 368 assert.notEqual(a.authentication$, b.authentication$); 369 b.authentication$.next({ 370 ...raw, 371 kind: 22242, 372 pubkey: owner 373 } as never); 374 assert.equal(a.authentication, null); 375 } 376 assert.equal(signs, 0); 377 assert.ok( 378 frames.every((frame) => frame[0] !== 'AUTH' && frame[0] !== 'EVENT') 379 ); 380 const privateReq = frames.filter( 381 (frame) => (frame[2] as { kinds?: number[] })?.kinds?.[0] === 1059 382 ); 383 assert.equal(privateReq.length, 3); 384 for (const frame of privateReq) 385 assert.deepEqual(frame[2], { 386 kinds: [1059], 387 '#p': [owner], 388 limit: 200 389 }); 390 } 391 ); 392 await t.test( 393 'logout closes actual private sockets and public discovery continues', 394 async () => { 395 const privateSockets = sockets.slice(3, 6); 396 const closed = privateSockets.map((socket) => once(socket, 'close')); 397 disconnectIdentity(identity); 398 await Promise.all(closed); 399 assert.equal(server.clients.size, 3); 400 assert.equal(privateSessionSnapshot(privateSession!)?.current, false); 401 assert.throws( 402 () => subscribePrivatePage(privatePool!, 1, () => {}), 403 /private_pool_closed/ 404 ); 405 await publicPage(); 406 assert.equal(constructed, 6); 407 } 408 ); 409 await t.test( 410 'same-author reconnect cannot revive an old scope or consume stale callbacks', 411 async () => { 412 await awaitRetirement(); 413 await connectIdentity(identity); 414 await probeIdentityMessaging(identity, 'reviewed_self_copy'); 415 assert.equal(privateSessionSnapshot(privateSession!)?.current, false); 416 const next = await createPrivateSession( 417 identity, 418 'reviewed_private_session' 419 ); 420 assert.ok(next); 421 assert.notEqual(next, privateSession); 422 privateSession = next; 423 privatePool = getPrivatePool(next, policy, origins); 424 assert.ok(privatePool); 425 const before = constructed; 426 await heldPage(); 427 assert.equal(constructed, before + 3); 428 } 429 ); 430 await t.test( 431 'failed SDK cleanup blocks replacement until exact cleanup retry succeeds', 432 async () => { 433 const before = constructed; 434 const held = sdkScopes.get('private'); 435 assert.ok(held); 436 RelayPool.prototype.close = function () { 437 if (this === held) throw new Error('HC_TEST_ONLY_CLOSE_FAILURE'); 438 return originalClose.call(this); 439 }; 440 // Actual session teardown owns whole-SDK disposal; an operation scope 441 // may close only its own work and cannot exercise this failure port. 442 assert.equal(closePrivateSession(privateSession!), false); 443 assert.throws( 444 () => getPrivatePool(privateSession!, policy, origins), 445 /private_session_invalid/ 446 ); 447 assert.equal( 448 await createPrivateSession(identity, 'reviewed_private_session'), 449 undefined 450 ); 451 const successorIdentity = createIdentitySession(); 452 await connectIdentity(successorIdentity); 453 await probeIdentityMessaging(successorIdentity, 'reviewed_self_copy'); 454 const blockedSuccessor = await createPrivateSession( 455 successorIdentity, 456 'reviewed_private_session' 457 ); 458 assert.ok(blockedSuccessor); 459 assert.throws( 460 () => getPrivatePool(blockedSuccessor, policy, origins), 461 /private_pool_closed/ 462 ); 463 closePrivateSession(blockedSuccessor); 464 disconnectIdentity(successorIdentity); 465 assert.equal(constructed, before); 466 RelayPool.prototype.close = originalClose; 467 while (!closePrivateSession(privateSession!)) 468 await new Promise<void>((resolve) => setImmediate(resolve)); 469 assert.equal(closePrivateSession(privateSession!), true); 470 const next = await createPrivateSession( 471 identity, 472 'reviewed_private_session' 473 ); 474 assert.ok(next); 475 privateSession = next; 476 privatePool = getPrivatePool(next, policy, origins); 477 assert.ok(privatePool); 478 } 479 ); 480 await t.test( 481 'observed account loss closes session generation without affecting public scope', 482 async () => { 483 privatePool = getPrivatePool(privateSession!, policy, origins); 484 assert.ok(privatePool); 485 await heldPage(); 486 const newest = [...server.clients].filter( 487 (socket) => !sockets.slice(0, 3).includes(socket) 488 ); 489 const closed = newest.map((socket) => once(socket, 'close')); 490 key = other; 491 await recheckIdentityOwner(identity); 492 await Promise.all(closed); 493 assert.equal(privateSessionSnapshot(privateSession!)?.current, false); 494 assert.equal( 495 await createPrivateSession(identity, 'reviewed_private_session'), 496 undefined 497 ); 498 await publicPage(); 499 assert.equal(signs, 0); 500 } 501 ); 502 key = owner; 503 await connectIdentity(identity); 504 await probeIdentityMessaging(identity, 'reviewed_self_copy'); 505 privateSession = await createPrivateSession( 506 identity, 507 'reviewed_private_session' 508 ); 509 assert.ok(privateSession); 510 privatePool = getPrivatePool(privateSession, policy, origins); 511 assert.ok(privatePool); 512 await t.test( 513 'oversized raw envelope is counted and rejected before consumer delivery', 514 async () => { 515 delivery = 'oversize'; 516 let candidates = 0; 517 await new Promise<void>((resolve) => { 518 stops.push( 519 subscribePrivatePage(privatePool!, 200, (message) => { 520 if (message.type === 'candidate') candidates++; 521 else resolve(); 522 }) 523 ); 524 }); 525 assert.equal(candidates, 0); 526 delivery = 'normal'; 527 } 528 ); 529 await t.test( 530 'duplicate deliveries consume the finite 500-candidate budget', 531 async () => { 532 delivery = 'flood'; 533 let candidates = 0; 534 const end = await new Promise<PrivatePageMessage>((resolve) => { 535 stops.push( 536 subscribePrivatePage(privatePool!, 200, (message) => { 537 if (message.type === 'candidate') candidates++; 538 else resolve(message); 539 }) 540 ); 541 }); 542 assert.equal(candidates, 500); 543 assert.deepEqual(end, { type: 'end', reason: 'budget' }); 544 delivery = 'normal'; 545 } 546 ); 547 await t.test( 548 'encoded bytes and rejected envelopes consume the exact finite 8MiB budget', 549 async () => { 550 delivery = 'byte-flood'; 551 let candidates = 0, 552 bytes = 0; 553 const end = await new Promise<PrivatePageMessage>((resolve) => { 554 stops.push( 555 subscribePrivatePage(privatePool!, 200, (message) => { 556 if (message.type === 'candidate') { 557 candidates++; 558 bytes += Buffer.byteLength(message.wire, 'utf8'); 559 } else resolve(message); 560 }) 561 ); 562 }); 563 const charge = Buffer.byteLength( 564 JSON.stringify({ ...raw, content: 'x'.repeat(20000) }), 565 'utf8' 566 ); 567 assert.equal(candidates, Math.floor(8388608 / charge)); 568 assert.ok(bytes <= 8388608); 569 assert.deepEqual(end, { type: 'end', reason: 'budget' }); 570 delivery = 'rejected-byte-flood'; 571 let rejectedCandidates = 0; 572 const rejectedEnd = await new Promise<PrivatePageMessage>((resolve) => { 573 stops.push( 574 subscribePrivatePage(privatePool!, 200, (message) => { 575 if (message.type === 'candidate') rejectedCandidates++; 576 else resolve(message); 577 }) 578 ); 579 }); 580 assert.equal(rejectedCandidates, 0); 581 assert.deepEqual(rejectedEnd, { type: 'end', reason: 'budget' }); 582 delivery = 'normal'; 583 } 584 ); 585 await t.test( 586 'finite network page enforces the original 15second elapsed boundary', 587 async () => { 588 delivery = 'hold'; 589 const original = performance.now.bind(performance), 590 descriptor = Object.getOwnPropertyDescriptor(performance, 'now'); 591 let observations = 0; 592 Object.defineProperty(performance, 'now', { 593 configurable: true, 594 value: () => { 595 observations++; 596 return original() + (observations > 1 ? 15000 : 0); 597 } 598 }); 599 try { 600 const end = await new Promise<PrivatePageMessage>((resolve) => { 601 stops.push( 602 subscribePrivatePage(privatePool!, 200, (message) => { 603 if (message.type === 'end') resolve(message); 604 }) 605 ); 606 }); 607 assert.ok(observations > 1); 608 assert.deepEqual(end, { type: 'end', reason: 'elapsed' }); 609 } finally { 610 if (descriptor) Object.defineProperty(performance, 'now', descriptor); 611 else Reflect.deleteProperty(performance, 'now'); 612 delivery = 'normal'; 613 } 614 } 615 ); 616 await t.test( 617 'asynchronous EOSE cleanup failure emits error and retains unavailable page without escaping', 618 async () => { 619 delivery = 'normal'; 620 const original = Reflect.get(Subscription.prototype, 'unsubscribe'); 621 let failNext = true; 622 Subscription.prototype.unsubscribe = function () { 623 if (failNext && new Error().stack?.includes('at release (')) { 624 failNext = false; 625 throw new Error('HC_TEST_ONLY_ASYNC_UNSUBSCRIBE_FAILURE'); 626 } 627 return original.call(this); 628 }; 629 try { 630 const end = await new Promise<PrivatePageMessage>((resolve) => { 631 stops.push( 632 subscribePrivatePage(privatePool!, 200, (message) => { 633 if (message.type === 'end') resolve(message); 634 }) 635 ); 636 }); 637 assert.deepEqual(end, { type: 'end', reason: 'error' }); 638 assert.throws( 639 () => subscribePrivatePage(privatePool!, 1, () => {}), 640 /private_page_cleanup_required/ 641 ); 642 await new Promise<void>((resolve) => setImmediate(resolve)); 643 } finally { 644 Subscription.prototype.unsubscribe = original; 645 closePrivatePool(privatePool!); 646 await awaitRetirement(); 647 privatePool = getPrivatePool(privateSession!, policy, origins); 648 assert.ok(privatePool); 649 } 650 } 651 ); 652 await t.test( 653 'failed page unsubscribe keeps new SDK admission blocked until cleanup retry', 654 async () => { 655 await heldPage(); 656 const stop = stops[stops.length - 1]; 657 const original = Reflect.get(Subscription.prototype, 'unsubscribe'); 658 let failNext = true; 659 Subscription.prototype.unsubscribe = function () { 660 if (failNext) { 661 failNext = false; 662 throw new Error('HC_TEST_ONLY_UNSUBSCRIBE_FAILURE'); 663 } 664 return original.call(this); 665 }; 666 let unexpected: (() => void) | undefined; 667 const before = requestCalls; 668 try { 669 assert.throws(() => stop(), /HC_TEST_ONLY_UNSUBSCRIBE_FAILURE/); 670 assert.throws(() => { 671 unexpected = subscribePrivatePage(privatePool!, 1, () => {}); 672 }, /private_pool_closed|private_page_cleanup_required/); 673 assert.equal(requestCalls, before); 674 } finally { 675 unexpected?.(); 676 Subscription.prototype.unsubscribe = original; 677 closePrivatePool(privatePool!); 678 await awaitRetirement(); 679 } 680 } 681 ); 682 await t.test( 683 'clock reentry cannot admit an SDK request after owner logout', 684 async () => { 685 await new Promise<void>((resolve) => setImmediate(resolve)); 686 assert.equal( 687 (await recheckIdentityOwner(identity)).state, 688 'messaging_capable' 689 ); 690 privatePool = getPrivatePool(privateSession!, policy, origins); 691 assert.ok(privatePool); 692 const original = performance.now.bind(performance); 693 const descriptor = Object.getOwnPropertyDescriptor(performance, 'now'); 694 const before = requestCalls; 695 let invalidations = 0; 696 Object.defineProperty(performance, 'now', { 697 configurable: true, 698 value: () => { 699 invalidations++; 700 disconnectIdentity(identity); 701 return original(); 702 } 703 }); 704 try { 705 await new Promise<void>((resolve) => { 706 stops.push( 707 subscribePrivatePage(privatePool!, 1, (message) => { 708 if (message.type === 'end') resolve(); 709 }) 710 ); 711 }); 712 assert.ok(invalidations > 0); 713 assert.equal(requestCalls, before); 714 } finally { 715 if (descriptor) Object.defineProperty(performance, 'now', descriptor); 716 else Reflect.deleteProperty(performance, 'now'); 717 } 718 } 719 ); 720 await t.test( 721 'candidate clock reentry cannot disclose old-owner ciphertext after logout', 722 async () => { 723 await awaitRetirement(); 724 await connectIdentity(identity); 725 await probeIdentityMessaging(identity, 'reviewed_self_copy'); 726 privateSession = await createPrivateSession( 727 identity, 728 'reviewed_private_session' 729 ); 730 assert.ok(privateSession); 731 privatePool = getPrivatePool(privateSession, policy, [origins[0]]); 732 assert.ok(privatePool); 733 delivery = 'single'; 734 eventWritten = false; 735 let candidates = 0, 736 invalidations = 0; 737 const original = performance.now.bind(performance), 738 descriptor = Object.getOwnPropertyDescriptor(performance, 'now'); 739 Object.defineProperty(performance, 'now', { 740 configurable: true, 741 value: () => { 742 if (eventWritten) { 743 invalidations++; 744 disconnectIdentity(identity); 745 } 746 return original(); 747 } 748 }); 749 try { 750 await new Promise<void>((resolve) => { 751 stops.push( 752 subscribePrivatePage(privatePool!, 1, (message) => { 753 if (message.type === 'candidate') candidates++; 754 else resolve(); 755 }) 756 ); 757 }); 758 assert.ok(eventWritten && invalidations > 0); 759 assert.equal(candidates, 0); 760 assert.equal(privateSessionSnapshot(privateSession)?.current, false); 761 } finally { 762 if (descriptor) Object.defineProperty(performance, 'now', descriptor); 763 else Reflect.deleteProperty(performance, 'now'); 764 delivery = 'normal'; 765 } 766 } 767 ); 768 await t.test( 769 'delayed genuine SDK owner response cannot open old-session sockets after logout', 770 async () => { 771 await awaitRetirement(); 772 await connectIdentity(identity); 773 await probeIdentityMessaging(identity, 'reviewed_self_copy'); 774 privateSession = await createPrivateSession( 775 identity, 776 'reviewed_private_session' 777 ); 778 assert.ok(privateSession); 779 privatePool = getPrivatePool(privateSession, policy, origins); 780 assert.ok(privatePool); 781 const browser = Reflect.get(globalThis, 'window'); 782 const provider: unknown = browser.nostr; 783 assert.ok(provider && typeof provider === 'object'); 784 const descriptor = Object.getOwnPropertyDescriptor( 785 provider, 786 'getPublicKey' 787 ); 788 assert.ok(descriptor); 789 let release = (_key: string) => { 790 void _key; 791 }; 792 let entered = () => {}; 793 const observed = new Promise<void>((resolve) => { 794 entered = resolve; 795 }); 796 Object.defineProperty(provider, 'getPublicKey', { 797 configurable: true, 798 value: () => { 799 entered(); 800 return new Promise<string>((resolve) => { 801 release = resolve; 802 }); 803 } 804 }); 805 const before = requestCalls; 806 let candidates = 0; 807 const end = new Promise<PrivatePageMessage>((resolve) => { 808 stops.push( 809 subscribePrivatePage(privatePool!, 1, (message) => { 810 if (message.type === 'candidate') candidates++; 811 else resolve(message); 812 }) 813 ); 814 }); 815 try { 816 await observed; 817 disconnectIdentity(identity); 818 assert.deepEqual(await end, { type: 'end', reason: 'closed' }); 819 Object.defineProperty(provider, 'getPublicKey', descriptor); 820 release(owner); 821 await new Promise<void>((resolve) => setImmediate(resolve)); 822 assert.equal(requestCalls, before); 823 assert.equal(candidates, 0); 824 assert.equal(privateSessionSnapshot(privateSession)?.current, false); 825 key = other; 826 await connectIdentity(identity); 827 await probeIdentityMessaging(identity, 'reviewed_self_copy'); 828 const next = await createPrivateSession( 829 identity, 830 'reviewed_private_session' 831 ); 832 assert.ok(next); 833 assert.deepEqual(privateSessionSnapshot(next), { 834 owner: other, 835 current: true 836 }); 837 assert.equal(privateSessionSnapshot(privateSession)?.current, false); 838 closePrivateSession(next); 839 disconnectIdentity(identity); 840 key = owner; 841 } finally { 842 Object.defineProperty(provider, 'getPublicKey', descriptor); 843 release(owner); 844 } 845 } 846 ); 847 await t.test( 848 'capability loss closes actual private transport and signing alone cannot reopen it', 849 async () => { 850 await awaitRetirement(); 851 await connectIdentity(identity); 852 await probeIdentityMessaging(identity, 'reviewed_self_copy'); 853 privateSession = await createPrivateSession( 854 identity, 855 'reviewed_private_session' 856 ); 857 assert.ok(privateSession); 858 privatePool = getPrivatePool(privateSession, policy, origins); 859 assert.ok(privatePool); 860 await heldPage(); 861 const newest = [...server.clients].filter( 862 (socket) => !sockets.slice(0, 3).includes(socket) 863 ); 864 const closed = newest.map((socket) => once(socket, 'close')); 865 const browser = Reflect.get(globalThis, 'window'); 866 const provider: unknown = browser.nostr; 867 assert.ok(provider && typeof provider === 'object'); 868 Object.defineProperty(provider, 'nip44', { 869 configurable: true, 870 value: undefined 871 }); 872 const checked = await recheckIdentityOwner(identity); 873 await Promise.all(closed); 874 assert.equal(checked.state, 'signing_only'); 875 assert.equal(privateSessionSnapshot(privateSession)?.current, false); 876 const before = constructed; 877 assert.equal( 878 await createPrivateSession(identity, 'reviewed_private_session'), 879 undefined 880 ); 881 assert.equal(constructed, before); 882 await publicPage(); 883 } 884 ); 885 } finally { 886 RelayPool.prototype.close = originalClose; 887 if (privatePool) closePrivatePool(privatePool); 888 if (privateSession) closePrivateSession(privateSession); 889 disconnectIdentity(identity); 890 for (const stop of stops) stop(); 891 if (publicPool) closePublicPool(publicPool); 892 RelayPool.prototype.req = originalReq; 893 for (const scope of allScopes) scope.close(); 894 for (const socket of server.clients) socket.terminate(); 895 await new Promise<void>((resolve, reject) => 896 server.close((error) => (error ? reject(error) : resolve())) 897 ); 898 globalThis.WebSocket = originalSocket; 899 globalThis.fetch = originalFetch; 900 Reflect.deleteProperty(globalThis, 'window'); 901 } 902 });