private-publisher.spec.ts (18723B)
1 import { test, expect } from '@playwright/test'; 2 import { build } from 'vite'; 3 import { fileURLToPath } from 'node:url'; 4 import { once } from 'node:events'; 5 import { WebSocketServer, type WebSocket } from 'ws'; 6 import { createStaticHarness } from '../integration/harness/static.ts'; 7 import type * as Fixture from './harness/private-publisher.ts'; 8 declare global { 9 interface Window { 10 hcp085: typeof Fixture; 11 hcp085Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>; 12 hcp085DelayClose?: boolean; 13 hcp085HeldClose?: (() => void)[]; 14 hcp085SharedAction?: NonNullable< 15 ReturnType<Window['hcp085Fixture']['action']> 16 >; 17 } 18 } 19 let server: Awaited<ReturnType<typeof createStaticHarness>>, 20 sockets: WebSocketServer, 21 endpoint: string, 22 bundle: string; 23 let frames: { origin: string; frame: unknown[] }[] = [], 24 response: 'accepted' | 'refused' | 'unknown' = 'accepted'; 25 const physical = new Set<WebSocket>(); 26 let constructed = 0, 27 peak = 0; 28 test.beforeAll(async () => { 29 server = await createStaticHarness(); 30 sockets = new WebSocketServer({ 31 host: '127.0.0.1', 32 port: 0, 33 maxPayload: 65536 34 }); 35 await once(sockets, 'listening'); 36 const address = sockets.address(); 37 if (!address || typeof address === 'string') 38 throw Error('loopback unavailable'); 39 endpoint = 'ws://127.0.0.1:' + address.port; 40 sockets.on('connection', (socket, request) => { 41 physical.add(socket); 42 constructed++; 43 peak = Math.max(peak, physical.size); 44 socket.on('close', () => physical.delete(socket)); 45 const origin = new URL(request.url!, 'http://127.0.0.1').searchParams.get( 46 'origin' 47 )!; 48 socket.on('message', (bytes) => { 49 const raw = Buffer.isBuffer(bytes) 50 ? bytes 51 : Array.isArray(bytes) 52 ? Buffer.concat(bytes) 53 : Buffer.from(bytes); 54 const frame = JSON.parse(raw.toString()) as unknown[]; 55 frames.push({ origin, frame }); 56 if (frame[0] === 'EVENT' && response !== 'unknown') { 57 const event = frame[1] as { id: string }; 58 socket.send( 59 JSON.stringify([ 60 'OK', 61 event.id, 62 response === 'accepted', 63 response === 'accepted' ? '' : 'blocked: fixture refusal' 64 ]) 65 ); 66 } else if (frame[0] === 'REQ') { 67 socket.send(JSON.stringify(['EOSE', frame[1]])); 68 } 69 }); 70 }); 71 const result = await build({ 72 configFile: false, 73 logLevel: 'silent', 74 build: { 75 write: false, 76 minify: false, 77 lib: { 78 entry: fileURLToPath( 79 new URL('./harness/private-publisher.ts', import.meta.url) 80 ), 81 name: 'hcp085', 82 formats: ['iife'] 83 } 84 } 85 }); 86 const output = Array.isArray(result) ? result[0] : result; 87 if (!('output' in output)) throw Error('bundle unavailable'); 88 const chunks = output.output.filter((x) => x.type === 'chunk'); 89 expect(chunks).toHaveLength(1); 90 bundle = chunks[0].code; 91 }); 92 test.afterAll(async () => { 93 for (const s of sockets.clients) s.terminate(); 94 await new Promise<void>((resolve) => sockets.close(() => resolve())); 95 await server.close(); 96 }); 97 test.beforeEach(async ({ page }) => { 98 await expect.poll(() => physical.size).toBe(0); 99 constructed = 0; 100 peak = 0; 101 frames = []; 102 response = 'accepted'; 103 await page.addInitScript( 104 ({ endpoint }) => { 105 const Native = window.WebSocket; 106 window.WebSocket = class extends Native { 107 constructor(url: string | URL, protocols?: string | string[]) { 108 const parsed = new URL(String(url)); 109 if ( 110 !['wss://peer.example.org', 'wss://archive.example.org'].includes( 111 parsed.origin 112 ) 113 ) 114 throw Error('unapproved fixture destination'); 115 super( 116 endpoint + '/?origin=' + encodeURIComponent(parsed.origin), 117 protocols 118 ); 119 } 120 override close(code?: number, reason?: string) { 121 if (window.hcp085DelayClose) 122 (window.hcp085HeldClose ??= []).push(() => 123 super.close(code, reason) 124 ); 125 else super.close(code, reason); 126 } 127 }; 128 }, 129 { endpoint } 130 ); 131 await page.goto(server.url + '/search'); 132 await page.addScriptTag({ content: bundle }); 133 }); 134 test.afterEach(async ({ page }) => { 135 if (!page.isClosed()) 136 await page.evaluate(() => { 137 window.hcp085DelayClose = false; 138 for (const release of window.hcp085HeldClose ?? []) release(); 139 window.hcp085Fixture?.close(); 140 }); 141 }); 142 async function fixture( 143 page: import('@playwright/test').Page, 144 writeOnly = false 145 ) { 146 await page.evaluate(async (writeOnly) => { 147 window.hcp085Fixture = await window.hcp085.makeFixture(writeOnly); 148 }, writeOnly); 149 } 150 test('missing and self-only persisted artifacts never acquire a private delivery capability', async ({ 151 page 152 }) => { 153 await fixture(page); 154 const result = await page.evaluate(async () => { 155 const f = window.hcp085Fixture; 156 const missing = !!f.permission('peer'); 157 const self = await f.prepareSelfOnly(); 158 return { 159 missing, 160 self: self.status, 161 selfOnly: !!f.permission('peer'), 162 delivery: await f.deliver('peer') 163 }; 164 }); 165 expect(result).toEqual({ 166 missing: false, 167 self: 'saved', 168 selfOnly: false, 169 delivery: { status: 'invalid' } 170 }); 171 expect(frames).toEqual([]); 172 }); 173 test('actual SDK loopback sees only exact persisted independent peer and archive1059 bytes', async ({ 174 page 175 }) => { 176 await fixture(page); 177 const result = await page.evaluate(async () => { 178 const f = window.hcp085Fixture; 179 const row = await f.prepare(); 180 const before = f.counts(); 181 const peer = await f.deliver('peer'), 182 archive = await f.deliver('self_archive'); 183 const after = f.counts(); 184 return { 185 row, 186 peer, 187 archive, 188 before: { 189 encrypts: before.encrypts, 190 decrypts: before.decrypts, 191 signs: before.signs 192 }, 193 after: { 194 encrypts: after.encrypts, 195 decrypts: after.decrypts, 196 signs: after.signs 197 }, 198 marker: f.marker 199 }; 200 }); 201 expect(result.peer.status).toBe('accepted'); 202 expect(result.archive.status).toBe('accepted'); 203 expect(result.after).toEqual(result.before); 204 const events = frames.filter((x) => x.frame[0] === 'EVENT'); 205 expect(events).toHaveLength(2); 206 expect(events.map((x) => x.origin)).toEqual([ 207 'wss://peer.example.org', 208 'wss://archive.example.org' 209 ]); 210 const stored = [result.row!.peerArtifact!, result.row!.self]; 211 for (let i = 0; i < events.length; i++) { 212 expect(JSON.stringify(events[i].frame[1])).toBe(stored[i].wire); 213 expect((events[i].frame[1] as { kind: number }).kind).toBe(1059); 214 } 215 expect(JSON.stringify(frames)).not.toContain(result.marker); 216 expect(stored[0].eventId).not.toBe(stored[1].eventId); 217 }); 218 test('raw14 and13 and even a genuine signed1059 object cannot replace opaque persisted permission', async ({ 219 page 220 }) => { 221 await fixture(page); 222 const statuses = await page.evaluate(async () => { 223 const f = window.hcp085Fixture, 224 row = await f.prepare(); 225 if (!row?.peerArtifact) throw Error('missing actual peer ciphertext'); 226 const event = JSON.parse(row.peerArtifact.wire) as Record<string, unknown>; 227 const results = []; 228 for (const kind of [14, 13, 1059]) 229 results.push( 230 ( 231 await window.hcp085.publishPrivateGiftWrapAttempt( 232 f.pool, 233 { ...event, kind } as unknown as Parameters< 234 typeof window.hcp085.publishPrivateGiftWrapAttempt 235 >[1], 236 new AbortController().signal 237 ) 238 ).status 239 ); 240 return results; 241 }); 242 expect(statuses).toEqual(['stopped', 'stopped', 'stopped']); 243 expect(frames).toEqual([]); 244 }); 245 test('role mismatches and unreviewed targets reject without a network effect', async ({ 246 page 247 }) => { 248 await fixture(page); 249 const result = await page.evaluate(async () => { 250 const f = window.hcp085Fixture; 251 await f.prepare(); 252 return [ 253 !!f.permission('peer', f.archiveOrigin), 254 !!f.permission('self_archive', f.peerOrigin), 255 !!f.permission('peer', 'wss://other.example.org'), 256 !!f.permission('peer', f.peerOrigin, 'not_reviewed') 257 ]; 258 }); 259 expect(result).toEqual([false, false, false, false]); 260 expect(frames).toEqual([]); 261 }); 262 for (const mode of ['remove', 'revision', 'readback'] as const) 263 test( 264 'actual ' + 265 mode + 266 ' after capture prevents EVENT from stale persisted evidence', 267 async ({ page }) => { 268 await fixture(page); 269 const result = await page.evaluate(async (mode) => { 270 const f = window.hcp085Fixture; 271 await f.prepare(); 272 const permission = f.permission('peer'); 273 if (!permission) throw Error('permission missing'); 274 if (mode === 'remove') await f.remove(); 275 else if (mode === 'revision') await f.changePairRevision(); 276 else f.failReadback(); 277 return f.publish(permission); 278 }, mode); 279 expect(result.status).toBe('stopped'); 280 expect(frames).toEqual([]); 281 } 282 ); 283 for (const mode of ['Stop', 'Disconnect', 'changed key'] as const) 284 test( 285 mode + ' before effect fences the exact candidate and opens no socket', 286 async ({ page }) => { 287 await fixture(page); 288 const result = await page.evaluate(async (mode) => { 289 const f = window.hcp085Fixture; 290 await f.prepare(); 291 const permission = f.permission('peer'); 292 if (!permission) throw Error('permission missing'); 293 if (mode === 'Stop') f.stop(); 294 else if (mode === 'Disconnect') f.disconnect(); 295 else f.mode('changed_key'); 296 return f.publish(permission); 297 }, mode); 298 expect(result.status).toBe('stopped'); 299 expect(frames).toEqual([]); 300 } 301 ); 302 test('one opaque permission cannot issue a second SDK EVENT and detached views cannot retarget it', async ({ 303 page 304 }) => { 305 await fixture(page); 306 const result = await page.evaluate(async () => { 307 const f = window.hcp085Fixture; 308 await f.prepare(); 309 const p = f.permission('peer'); 310 if (!p) throw Error('permission missing'); 311 const view = window.hcp085.privatePublicationSnapshot(p)!; 312 const first = await f.publish(p); 313 const second = await f.publish(p); 314 return { first, second, view }; 315 }); 316 expect(result.first.status).toBe('accepted'); 317 expect(result.second.status).toBe('stopped'); 318 expect(result.view.role).toBe('peer'); 319 expect(frames.filter((x) => x.frame[0] === 'EVENT')).toHaveLength(1); 320 }); 321 test('actual relay refusal is a named attempt outcome without recipient or order success', async ({ 322 page 323 }) => { 324 response = 'refused'; 325 await fixture(page); 326 const result = await page.evaluate(async () => { 327 const f = window.hcp085Fixture; 328 await f.prepare(); 329 return f.deliver('self_archive'); 330 }); 331 expect(result.status).toBe('refused'); 332 expect(frames.filter((x) => x.frame[0] === 'EVENT')).toHaveLength(1); 333 }); 334 test('a write-only destination can publish but private reads stay on read-admitted origins', async ({ 335 page 336 }) => { 337 await fixture(page, true); 338 const result = await page.evaluate(async () => { 339 const f = window.hcp085Fixture; 340 await f.prepare(); 341 const write = await f.deliver('peer'); 342 await f.readOrigins(); 343 return write; 344 }); 345 expect(result.status).toBe('accepted'); 346 expect( 347 frames.filter((x) => x.frame[0] === 'REQ').map((x) => x.origin) 348 ).toEqual(['wss://archive.example.org']); 349 }); 350 for (const newer of [false, true]) 351 test( 352 'successful same-owner actual delivery preserves ' + 353 (newer ? 'newer unsaved text' : 'captured saved encrypted text') + 354 ' and its composer state', 355 async ({ page }) => { 356 await fixture(page); 357 const result = await page.evaluate(async (newer) => { 358 const f = window.hcp085Fixture; 359 await f.prepare(); 360 const before = f.bindComposer(newer); 361 const delivery = await f.deliver('peer'); 362 return { before, delivery, after: f.composerState() }; 363 }, newer); 364 expect(result.delivery.status).toBe('accepted'); 365 expect(result.after).toEqual(result.before); 366 expect(result.before.snapshot?.dirty).toBe(newer); 367 expect(result.before.snapshot?.state).toBe( 368 newer ? 'unsaved' : 'saved_encrypted' 369 ); 370 expect(frames.filter((x) => x.frame[0] === 'EVENT')).toHaveLength(1); 371 expect(JSON.stringify(frames)).not.toContain( 372 'HCP085_NEWER_PRIVATE_TEXT_MEMORY_ONLY' 373 ); 374 } 375 ); 376 test('actual owner loss still clears the bound private composer and prevents publication', async ({ 377 page 378 }) => { 379 await fixture(page); 380 const result = await page.evaluate(async () => { 381 const f = window.hcp085Fixture; 382 await f.prepare(); 383 const before = f.bindComposer(true); 384 const permission = f.permission('peer'); 385 if (!permission) throw Error('missing actual permission'); 386 f.disconnect(); 387 return { 388 before, 389 after: f.composerState(), 390 attempt: await f.publish(permission) 391 }; 392 }); 393 expect(result.before.snapshot?.dirty).toBe(true); 394 expect(result.after).toEqual({ text: undefined, snapshot: undefined }); 395 expect(result.attempt.status).toBe('stopped'); 396 expect(frames).toEqual([]); 397 }); 398 399 for (const fault of ['SDK acquisition', 'actual network clock abort'] as const) 400 test( 401 'original metered action releases reservation after ' + 402 fault + 403 ' and permits reviewed retry', 404 async ({ page }) => { 405 await fixture(page); 406 const result = await page.evaluate(async (fault) => { 407 const f = window.hcp085Fixture; 408 await f.prepare(); 409 const action = f.action(); 410 if (!action) throw Error('genuine metered action missing'); 411 const firstPermission = f.permission( 412 'peer', 413 f.peerOrigin, 414 'reviewed_private_delivery', 415 action 416 ); 417 if (!firstPermission) throw Error('genuine first permission missing'); 418 const abort = new AbortController(); 419 let restore: () => void, 420 observed = () => true; 421 if (fault === 'SDK acquisition') restore = f.failAcquisition(); 422 else { 423 const clock = f.abortOnActualNetworkClock(abort); 424 restore = clock.restore; 425 observed = clock.observed; 426 } 427 let first; 428 try { 429 first = await f.publish(firstPermission, abort.signal); 430 } finally { 431 restore(); 432 } 433 const retryPermission = f.permission( 434 'peer', 435 f.peerOrigin, 436 'reviewed_private_delivery', 437 action 438 ); 439 if (!retryPermission) 440 throw Error('genuine original action retry permission missing'); 441 const retry = await f.publish( 442 retryPermission, 443 new AbortController().signal 444 ); 445 return { first, retry, observed: observed() }; 446 }, fault); 447 expect(result.observed).toBe(true); 448 expect(result.first.status).toBe('stopped'); 449 expect(result.first.actionId).toBeUndefined(); 450 expect(result.first.attempt).toBeUndefined(); 451 expect(result.retry.status).toBe('accepted'); 452 expect(result.retry.attempt).toBe(fault === 'SDK acquisition' ? 1 : 2); 453 expect(frames.filter(({ frame }) => frame[0] === 'EVENT')).toHaveLength( 454 1 455 ); 456 } 457 ); 458 459 test('genuine shared-origin peer and archive roles reuse one original connection and distinct exact artifacts', async ({ 460 page 461 }) => { 462 const result = await page.evaluate(async () => { 463 window.hcp085Fixture = await window.hcp085.makeFixture(false, true); 464 const f = window.hcp085Fixture; 465 window.hcp085DelayClose = true; 466 await f.prepare(); 467 const action = f.action(); 468 if (!action) throw Error('genuine metered action'); 469 const peer = f.permission( 470 'peer', 471 f.peerOrigin, 472 'reviewed_private_delivery', 473 action 474 ); 475 const archive = f.permission( 476 'self_archive', 477 f.archiveOrigin, 478 'reviewed_private_delivery', 479 action 480 ); 481 if (!peer || !archive) throw Error('genuine original two-role permissions'); 482 const first = await f.publish(peer); 483 const second = await f.publish(archive); 484 const retry = f.permission( 485 'peer', 486 f.peerOrigin, 487 'reviewed_private_delivery', 488 action 489 ); 490 if (!retry) throw Error('genuine reviewed original retry'); 491 const third = await f.publish(retry); 492 return { first, second, third }; 493 }); 494 expect(constructed).toBe(1); 495 expect(peak).toBe(1); 496 expect(physical.size).toBe(1); 497 expect(await page.evaluate(() => window.hcp085HeldClose?.length ?? 0)).toBe( 498 0 499 ); 500 expect(result.first.status).toBe('accepted'); 501 expect(result.second.status).toBe('accepted'); 502 expect(result.third.status).toBe('accepted'); 503 expect(result.first.eventId).not.toBe(result.second.eventId); 504 expect(result.third.eventId).toBe(result.first.eventId); 505 expect(result.third.attempt).toBe(2); 506 const events = frames.filter(({ frame }) => frame[0] === 'EVENT'); 507 expect(events).toHaveLength(3); 508 expect( 509 events.every(({ origin }) => origin === 'wss://peer.example.org') 510 ).toBe(true); 511 }); 512 513 test('original shared-origin unknown EVENT retries the exact artifact on the same actual connection', async ({ 514 page 515 }) => { 516 response = 'unknown'; 517 const first = await page.evaluate(async () => { 518 window.hcp085Fixture = await window.hcp085.makeFixture(false, true); 519 const f = window.hcp085Fixture; 520 window.hcp085DelayClose = true; 521 await f.prepare(); 522 window.hcp085SharedAction = f.action(); 523 if (!window.hcp085SharedAction) throw Error('genuine action'); 524 const permission = f.permission( 525 'peer', 526 f.peerOrigin, 527 'reviewed_private_delivery', 528 window.hcp085SharedAction 529 ); 530 if (!permission) throw Error('genuine permission'); 531 return f.publish(permission); 532 }); 533 expect(['unknown', 'timed_out']).toContain(first.status); 534 expect(constructed).toBe(1); 535 response = 'accepted'; 536 const retry = await page.evaluate(async () => { 537 const f = window.hcp085Fixture; 538 const permission = f.permission( 539 'peer', 540 f.peerOrigin, 541 'reviewed_private_delivery', 542 window.hcp085SharedAction 543 ); 544 if (!permission) throw Error('genuine original explicit retry permission'); 545 return f.publish(permission); 546 }); 547 expect(retry.status).toBe('accepted'); 548 expect(retry.eventId).toBe(first.eventId); 549 expect(retry.attempt).toBe(2); 550 expect(constructed).toBe(1); 551 expect(peak).toBe(1); 552 const events = frames.filter(({ frame }) => frame[0] === 'EVENT'); 553 expect(events).toHaveLength(2); 554 expect(events[1].frame[1]).toEqual(events[0].frame[1]); 555 });