message-metadata.ts (19381B)
1 import { 2 captureMessageMetadata, 3 messageMetadataSnapshot, 4 markDisplayedMessage, 5 type MessageMetadata, 6 MESSAGE_METADATA_DISCLOSURE 7 } from '../../../src/lib/persistence/message-metadata.ts'; 8 import { readLocalUnread } from '../../../src/lib/messaging/unread.ts'; 9 import { 10 openBrowserDatabase, 11 closeBrowserDatabase, 12 browserDatabaseTransaction, 13 type BrowserDatabase 14 } from '../../../src/lib/persistence/database.ts'; 15 import { 16 captureUnlockedSession, 17 acceptUnlockedConversation, 18 readUnlockedMessages, 19 unlockedSessionSnapshot, 20 closeUnlockedSession, 21 type UnlockedSession 22 } from '../../../src/lib/messaging/unlocked-session.ts'; 23 import { 24 getPrivateCacheScope, 25 retainPrivateCacheWire, 26 clearPrivateCacheScope, 27 privateCacheSnapshot, 28 type PrivateCacheScope 29 } from '../../../src/lib/nostr/private-cache-scope.ts'; 30 import { 31 createIdentitySession, 32 connectIdentity, 33 probeIdentityMessaging, 34 disconnectIdentity, 35 recheckIdentityOwner 36 } from '../../../src/lib/runtime/identity-session.ts'; 37 import { 38 getPublicKey, 39 getEventHash, 40 finalizeEvent, 41 type UnsignedEvent 42 } from 'applesauce-core/helpers'; 43 import { nip44 } from 'applesauce-core/helpers/encryption'; 44 import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts'; 45 import { 46 createPrivateSession, 47 closePrivateSession 48 } from '../../../src/lib/runtime/private-session.ts'; 49 import { 50 admitInboxEnvelope, 51 retainInboxEnvelope 52 } from '../../../src/lib/persistence/inbox-envelope-repository.ts'; 53 import { 54 captureReceivedUnwrap, 55 unwrapReceivedEnvelope, 56 stopReceivedUnwrap, 57 type ReceivedUnwrap, 58 type ReceivedNestedEnvelope 59 } from '../../../src/lib/nostr/unwrap-admission.ts'; 60 import { 61 admitReceivedConversation, 62 conversationSnapshot, 63 type AdmittedConversation 64 } from '../../../src/lib/messaging/admit-conversation.ts'; 65 type Scenario = 66 | 'inbound' 67 | 'self_archive' 68 | 'third_party' 69 | 'hostile_text' 70 | 'missing_parent'; 71 export async function makeFixture( 72 scenario: Scenario = 'inbound', 73 initialise = true 74 ) { 75 const f = await makeRecoveryFixture(initialise), 76 privateSession = await createPrivateSession( 77 f.identity, 78 'reviewed_private_session' 79 ); 80 if (!privateSession) throw Error('missing genuine private session'); 81 const ownerSecret = new Uint8Array(32).fill(83), 82 peerSecret = new Uint8Array(32).fill(84), 83 outerSecret = new Uint8Array(32).fill(85), 84 other = getPublicKey(outerSecret); 85 const senderSecret = scenario === 'self_archive' ? ownerSecret : peerSecret, 86 sender = getPublicKey(senderSecret), 87 recipient = 88 scenario === 'self_archive' 89 ? f.peer 90 : scenario === 'third_party' 91 ? other 92 : f.owner; 93 const tags: string[][] = [['p', recipient]]; 94 if (scenario === 'hostile_text') tags.push(['subject', other]); 95 if (scenario === 'missing_parent') 96 tags.push(['e', 'a'.repeat(64), 'wss://untrusted.example.org']); 97 const template: UnsignedEvent = { 98 pubkey: sender, 99 kind: 14, 100 created_at: 1700000000, 101 tags, 102 content: 103 scenario === 'hostile_text' 104 ? `Contact ${other} https://untrusted.example.org` 105 : 'Actual encrypted room fixture' 106 }, 107 rumor = { id: getEventHash(template), ...template }; 108 function encrypt(key: Uint8Array, target: string, plain: string) { 109 const conversation = nip44.v2.utils.getConversationKey(key, target); 110 try { 111 return nip44.v2.encrypt(plain, conversation); 112 } finally { 113 conversation.fill(0); 114 } 115 } 116 const seal = finalizeEvent( 117 { 118 kind: 13, 119 created_at: 1699999900, 120 tags: [], 121 content: encrypt(senderSecret, f.owner, JSON.stringify(rumor)) 122 }, 123 senderSecret 124 ); 125 const outer = finalizeEvent( 126 { 127 kind: 1059, 128 created_at: 1699999800, 129 tags: [['p', f.owner]], 130 content: encrypt(outerSecret, f.owner, JSON.stringify(seal)) 131 }, 132 outerSecret 133 ); 134 ownerSecret.fill(0); 135 peerSecret.fill(0); 136 outerSecret.fill(0); 137 const admitted = admitInboxEnvelope( 138 JSON.stringify(outer), 139 f.owner, 140 'wss://archive.example.org', 141 100 142 ); 143 if (!admitted) throw Error('missing signed addressed outer'); 144 const saved = await retainInboxEnvelope( 145 f.repository, 146 privateSession, 147 admitted 148 ); 149 if (saved.status !== 'retained') throw Error('no actual retained cipher'); 150 let reader: ReceivedUnwrap | undefined, 151 nested: ReceivedNestedEnvelope | undefined, 152 room: AdmittedConversation | undefined; 153 let unlocked: UnlockedSession | undefined; 154 let rawCache: PrivateCacheScope | undefined; 155 let database: BrowserDatabase | undefined, 156 metadata: MessageMetadata | undefined; 157 let otherMetadata: MessageMetadata | undefined; 158 let otherPrivateSession: Awaited<ReturnType<typeof createPrivateSession>>; 159 let otherIdentity: ReturnType<typeof createIdentitySession> | undefined; 160 return { 161 ...f, 162 other, 163 rumorId: rumor.id, 164 async unlock() { 165 reader = captureReceivedUnwrap( 166 f.repository, 167 f.identity, 168 outer.id, 169 'reviewed_inbox_unlock' 170 ); 171 if (!reader) return 'invalid'; 172 const result = await unwrapReceivedEnvelope(reader); 173 if (result.status === 'authenticated') nested = result.envelope; 174 return result.status; 175 }, 176 admit(role: unknown) { 177 room = nested && admitReceivedConversation(nested, role); 178 return room && conversationSnapshot(room); 179 }, 180 snapshot() { 181 return room && conversationSnapshot(room); 182 }, 183 forged() { 184 return admitReceivedConversation({} as ReceivedNestedEnvelope, 'inbound'); 185 }, 186 copied() { 187 return room && conversationSnapshot({ ...room }); 188 }, 189 captureCache(review: unknown = 'reviewed_messages_unlock') { 190 unlocked = captureUnlockedSession(privateSession, review); 191 if (unlocked) 192 rawCache = getPrivateCacheScope(privateSession, 'projection_ownership'); 193 return !!unlocked; 194 }, 195 cache() { 196 return unlocked && room 197 ? acceptUnlockedConversation(unlocked, room) 198 : 'rejected'; 199 }, 200 messages() { 201 return unlocked && readUnlockedMessages(unlocked); 202 }, 203 cacheSnapshot() { 204 return unlocked && unlockedSessionSnapshot(unlocked); 205 }, 206 rawCacheSnapshot() { 207 return rawCache && privateCacheSnapshot(rawCache); 208 }, 209 forgedCache() { 210 return ( 211 unlocked && 212 acceptUnlockedConversation(unlocked, {} as AdmittedConversation) 213 ); 214 }, 215 copiedCache() { 216 return ( 217 unlocked && room && acceptUnlockedConversation(unlocked, { ...room }) 218 ); 219 }, 220 closeCache() { 221 if (unlocked) closeUnlockedSession(unlocked); 222 }, 223 closePrivate() { 224 closePrivateSession(privateSession); 225 }, 226 async changedOwner() { 227 f.mode('changed_key'); 228 return await recheckIdentityOwner(f.identity); 229 }, 230 async otherGeneration() { 231 otherIdentity = createIdentitySession(); 232 await connectIdentity(otherIdentity); 233 await probeIdentityMessaging(otherIdentity, 'reviewed_self_copy'); 234 otherPrivateSession = await createPrivateSession( 235 otherIdentity, 236 'reviewed_private_session' 237 ); 238 if (!otherPrivateSession) 239 throw Error('missing other genuine private session'); 240 const scope = captureUnlockedSession( 241 otherPrivateSession, 242 'reviewed_messages_unlock' 243 ); 244 if (!scope || !room) throw Error('missing genuine scope/room'); 245 return { 246 accepted: acceptUnlockedConversation(scope, room), 247 snapshot: unlockedSessionSnapshot(scope) 248 }; 249 }, 250 quota() { 251 const scope = getPrivateCacheScope( 252 privateSession, 253 'projection_ownership' 254 ); 255 if (!scope) throw Error('missing actual scoped cache'); 256 for (let i = 0; i < 2000; i++) { 257 const result = retainPrivateCacheWire( 258 scope, 259 i.toString(16).padStart(64, '0'), 260 '{}' 261 ); 262 if (result !== 'accepted') 263 throw Error('unexpected quota fixture result ' + result); 264 } 265 return 2000; 266 }, 267 corruptCachedWire() { 268 const scope = getPrivateCacheScope( 269 privateSession, 270 'projection_ownership' 271 ); 272 if (!scope || !room) throw Error('missing actual cache'); 273 const snapshot = conversationSnapshot(room); 274 if (!snapshot) throw Error('no current room'); 275 clearPrivateCacheScope(scope); 276 return retainPrivateCacheWire( 277 scope, 278 snapshot.rumorId, 279 JSON.stringify({ 280 ...snapshot, 281 peer: other, 282 content: 'HOSTILE_CACHE_POISON' 283 }) 284 ); 285 }, 286 async captureMetadata(review: unknown = 'reviewed_local_message_metadata') { 287 if (!database) { 288 const opened = await openBrowserDatabase(); 289 if (opened.state !== 'ready') 290 throw Error('actual metadata database unavailable'); 291 database = opened.owner; 292 } 293 if (!unlocked) return false; 294 metadata = captureMessageMetadata( 295 database, 296 privateSession, 297 unlocked, 298 review 299 ); 300 return !!metadata; 301 }, 302 async unread() { 303 return metadata && (await readLocalUnread(metadata)); 304 }, 305 async metadataSnapshot() { 306 return metadata && (await messageMetadataSnapshot(metadata)); 307 }, 308 async display(review: unknown = 'displayed_message') { 309 return metadata && room 310 ? await markDisplayedMessage(metadata, room, review) 311 : { status: 'invalid' }; 312 }, 313 async forgedDisplay() { 314 return metadata 315 ? await markDisplayedMessage( 316 metadata, 317 {} as AdmittedConversation, 318 'displayed_message' 319 ) 320 : { status: 'invalid' }; 321 }, 322 async copiedDisplay() { 323 return metadata && room 324 ? await markDisplayedMessage(metadata, { ...room }, 'displayed_message') 325 : { status: 'invalid' }; 326 }, 327 disclosure() { 328 return MESSAGE_METADATA_DISCLOSURE; 329 }, 330 async rawMetadata() { 331 if (!database) throw Error('no actual database'); 332 const tx = browserDatabaseTransaction( 333 database, 334 ['received_envelopes', 'conversations'], 335 'readonly' 336 ); 337 const received = tx.objectStore('received_envelopes').getAll(), 338 pairs = tx.objectStore('conversations').getAll(); 339 return await new Promise<{ received: unknown[]; pairs: unknown[] }>( 340 (resolve, reject) => { 341 tx.addEventListener('complete', () => 342 resolve({ received: received.result, pairs: pairs.result }) 343 ); 344 tx.addEventListener('abort', () => 345 reject(Error('actual raw scan aborted')) 346 ); 347 } 348 ); 349 }, 350 async corruptPair() { 351 if (!database) throw Error('no actual database'); 352 const tx = browserDatabaseTransaction( 353 database, 354 ['conversations'], 355 'readwrite' 356 ); 357 tx.objectStore('conversations').put({ 358 owner: f.owner, 359 id: '12345678-1234-4234-8234-123456789abd', 360 wire: JSON.stringify({ 361 schema: 1, 362 family: 'conversation_handle', 363 owner: f.owner, 364 id: '12345678-1234-4234-8234-123456789abd', 365 peer: f.peer, 366 subject: 'FORBIDDEN_CONTEXT' 367 }) 368 }); 369 await new Promise<void>((resolve, reject) => { 370 tx.addEventListener('complete', () => resolve()); 371 tx.addEventListener('abort', () => 372 reject(Error('corruption fixture aborted')) 373 ); 374 }); 375 }, 376 abortNextWrite() { 377 const original = Object.getOwnPropertyDescriptor( 378 IDBObjectStore.prototype, 379 'put' 380 )?.value as IDBObjectStore['put']; 381 let consumed = false; 382 IDBObjectStore.prototype.put = function ( 383 ...args: Parameters<typeof original> 384 ) { 385 const request = original.apply(this, args); 386 if (this.name === 'received_envelopes' && !consumed) { 387 consumed = true; 388 this.transaction.abort(); 389 } 390 return request; 391 }; 392 return () => { 393 IDBObjectStore.prototype.put = original; 394 }; 395 }, 396 async otherOwnerMetadata() { 397 f.mode('changed_key'); 398 otherIdentity = createIdentitySession(); 399 await connectIdentity(otherIdentity); 400 await probeIdentityMessaging(otherIdentity, 'reviewed_self_copy'); 401 otherPrivateSession = await createPrivateSession( 402 otherIdentity, 403 'reviewed_private_session' 404 ); 405 if (!database || !otherPrivateSession) 406 throw Error('no genuine other owner'); 407 const scope = captureUnlockedSession( 408 otherPrivateSession, 409 'reviewed_messages_unlock' 410 ); 411 if (!scope) throw Error('no genuine other cache'); 412 const m = captureMessageMetadata( 413 database, 414 otherPrivateSession, 415 scope, 416 'reviewed_local_message_metadata' 417 ); 418 if (!m) throw Error('no genuine other metadata'); 419 otherMetadata = m; 420 return await messageMetadataSnapshot(m); 421 }, 422 async wrongGenerationMetadata() { 423 otherIdentity = createIdentitySession(); 424 await connectIdentity(otherIdentity); 425 await probeIdentityMessaging(otherIdentity, 'reviewed_self_copy'); 426 otherPrivateSession = await createPrivateSession( 427 otherIdentity, 428 'reviewed_private_session' 429 ); 430 if (!database || !otherPrivateSession || !unlocked) 431 throw Error('no genuine generation test'); 432 return !!captureMessageMetadata( 433 database, 434 otherPrivateSession, 435 unlocked, 436 'reviewed_local_message_metadata' 437 ); 438 }, 439 async queuedLogout() { 440 if (!metadata || !room) throw Error('no genuine current metadata/room'); 441 let release!: () => void, held!: () => void; 442 const ready = new Promise<void>((r) => { 443 held = r; 444 }); 445 const blocker = navigator.locks.request( 446 'harvestcircle:owner:' + f.owner, 447 async () => { 448 held(); 449 await new Promise<void>((r) => { 450 release = r; 451 }); 452 } 453 ); 454 await ready; 455 const pending = markDisplayedMessage(metadata, room, 'displayed_message'); 456 f.disconnect(); 457 release(); 458 await blocker; 459 return await pending; 460 }, 461 failNextReadback() { 462 const original = Object.getOwnPropertyDescriptor( 463 IDBIndex.prototype, 464 'openCursor' 465 )?.value as IDBIndex['openCursor']; 466 let reads = 0; 467 IDBIndex.prototype.openCursor = function ( 468 ...args: Parameters<typeof original> 469 ) { 470 if ( 471 this.objectStore.name === 'received_envelopes' && 472 this.objectStore.transaction.mode === 'readonly' && 473 ++reads === 2 474 ) 475 throw new DOMException('actual readback failure', 'AbortError'); 476 return original.apply(this, args); 477 }; 478 return () => { 479 IDBIndex.prototype.openCursor = original; 480 }; 481 }, 482 async raceNextWrite() { 483 if (!database) throw Error('no database'); 484 const rows = await this.rawMetadata(), 485 raw = ( 486 rows.received as { owner: string; id: string; wire: string }[] 487 ).find((x) => x.owner === f.owner); 488 if (!raw) throw Error('missing received race row'); 489 const record = JSON.parse(raw.wire) as { 490 revision: number; 491 sources: string[]; 492 }; 493 const wire = JSON.stringify({ 494 ...record, 495 revision: record.revision + 1, 496 sources: [...record.sources, 'wss://race.example.org'] 497 }); 498 const original = Object.getOwnPropertyDescriptor( 499 IDBDatabase.prototype, 500 'transaction' 501 )?.value as IDBDatabase['transaction']; 502 let injected = false; 503 IDBDatabase.prototype.transaction = function ( 504 ...args: Parameters<typeof original> 505 ) { 506 const stores = args[0], 507 mode = args[1]; 508 if ( 509 !injected && 510 mode === 'readwrite' && 511 Array.isArray(stores) && 512 stores.includes('received_envelopes') 513 ) { 514 injected = true; 515 const rival = original.call( 516 this, 517 ['received_envelopes'], 518 'readwrite' 519 ); 520 rival.objectStore('received_envelopes').put({ ...raw, wire }); 521 } 522 return original.apply(this, args); 523 }; 524 return () => { 525 IDBDatabase.prototype.transaction = original; 526 }; 527 }, 528 foreignNavigationSession() { 529 return otherPrivateSession; 530 }, 531 navigationInputs() { 532 return { privateSession, metadata, room }; 533 }, 534 async otherNavigationInputs() { 535 await this.otherOwnerMetadata(); 536 return { privateSession: otherPrivateSession, metadata: otherMetadata }; 537 }, 538 async anotherWrap(lateOld = false, productText?: string) { 539 const selectedTemplate = { 540 ...template, 541 created_at: 1, 542 content: productText ?? 'Late old actual encrypted rumor' 543 }, 544 selectedRumor = lateOld 545 ? { id: getEventHash(selectedTemplate), ...selectedTemplate } 546 : rumor; 547 let selectedSeal = seal; 548 if (lateOld) { 549 const peer = new Uint8Array(32).fill(84); 550 try { 551 selectedSeal = finalizeEvent( 552 { 553 kind: 13, 554 created_at: 1, 555 tags: [], 556 content: encrypt(peer, f.owner, JSON.stringify(selectedRumor)) 557 }, 558 peer 559 ); 560 } finally { 561 peer.fill(0); 562 } 563 } 564 565 const key = new Uint8Array(32).fill(86); 566 let next; 567 try { 568 next = finalizeEvent( 569 { 570 kind: 1059, 571 created_at: 1699999799, 572 tags: [['p', f.owner]], 573 content: encrypt(key, f.owner, JSON.stringify(selectedSeal)) 574 }, 575 key 576 ); 577 } finally { 578 key.fill(0); 579 } 580 const candidate = admitInboxEnvelope( 581 JSON.stringify(next), 582 f.owner, 583 'wss://archive.example.org', 584 101 585 ); 586 if (!candidate) throw Error('no second outer'); 587 const result = await retainInboxEnvelope( 588 f.repository, 589 privateSession, 590 candidate 591 ); 592 if (result.status !== 'retained') throw Error('no second retained outer'); 593 reader = captureReceivedUnwrap( 594 f.repository, 595 f.identity, 596 next.id, 597 'reviewed_inbox_unlock' 598 ); 599 if (!reader) throw Error('no genuine second reader'); 600 const opened = await unwrapReceivedEnvelope(reader); 601 if (opened.status !== 'authenticated') 602 throw Error('no actual second decrypt'); 603 nested = opened.envelope; 604 room = admitReceivedConversation( 605 nested, 606 scenario === 'self_archive' ? 'self_archive' : 'inbound' 607 ); 608 return { outerId: next.id, rumorId: selectedRumor.id }; 609 }, 610 stop() { 611 if (reader) stopReceivedUnwrap(reader); 612 }, 613 close() { 614 if (database) closeBrowserDatabase(database); 615 if (unlocked) closeUnlockedSession(unlocked); 616 if (otherPrivateSession) closePrivateSession(otherPrivateSession); 617 if (otherIdentity) disconnectIdentity(otherIdentity); 618 if (reader) stopReceivedUnwrap(reader); 619 closePrivateSession(privateSession); 620 f.close(); 621 } 622 }; 623 }