decryption-queue.ts (10469B)
1 import { 2 captureDecryptionQueue, 3 refreshDecryptionQueue, 4 runDecryptionBatch, 5 decryptionQueueSnapshot, 6 stopDecryptionQueue, 7 expireDecryptionQueueWait, 8 type DecryptionQueue 9 } from '../../../src/lib/messaging/decryption-queue.ts'; 10 import { decryptionQueueConversations } from '../../../src/lib/messaging/decryption-queue.ts'; 11 import { 12 privateBlocksForIdentity, 13 mountLocalPrivateBlocks, 14 blockLocalPrivatePeer, 15 undoLocalPrivatePeer, 16 localPrivateBlocksSnapshot 17 } from '../../../src/lib/persistence/local-private-blocks.ts'; 18 import { 19 captureReceivedUnwrap, 20 unwrapReceivedEnvelope, 21 stopReceivedUnwrap, 22 type ReceivedUnwrap 23 } from '../../../src/lib/nostr/unwrap-admission.ts'; 24 import { 25 admitReceivedConversation, 26 conversationSnapshot 27 } from '../../../src/lib/messaging/admit-conversation.ts'; 28 import { acceptUnlockedConversation } from '../../../src/lib/messaging/unlocked-session.ts'; 29 import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts'; 30 import { 31 createPrivateSession, 32 closePrivateSession 33 } from '../../../src/lib/runtime/private-session.ts'; 34 import { 35 captureUnlockedSession, 36 closeUnlockedSession, 37 readUnlockedMessages, 38 unlockedSessionSnapshot 39 } from '../../../src/lib/messaging/unlocked-session.ts'; 40 import { 41 admitInboxEnvelope, 42 retainInboxEnvelope 43 } from '../../../src/lib/persistence/inbox-envelope-repository.ts'; 44 import { listPrivateReceivedRecords } from '../../../src/lib/persistence/private-storage.ts'; 45 import { 46 privateRecordWire, 47 privateRecordIdentity 48 } from '../../../src/lib/persistence/private-records.ts'; 49 import { 50 finalizeEvent, 51 getPublicKey, 52 getEventHash 53 } from 'applesauce-core/helpers'; 54 import { nip44 } from 'applesauce-core/helpers/encryption'; 55 import { 56 browserExtensionScheduler, 57 extensionSchedulerSnapshot, 58 runExtensionAction 59 } from '../../../src/lib/nostr/extension-scheduler.ts'; 60 import { 61 identityMessagingOwnership, 62 createIdentitySession, 63 connectIdentity, 64 probeIdentityMessaging, 65 disconnectIdentity, 66 identitySessionSnapshot 67 } from '../../../src/lib/runtime/identity-session.ts'; 68 import { 69 getPublicStore, 70 publicStoreEnvelope 71 } from '../../../src/lib/nostr/public-store.ts'; 72 export async function makeFixture(count = 21, unknownSender = false) { 73 const f = await makeRecoveryFixture(); 74 const session = await createPrivateSession( 75 f.identity, 76 'reviewed_private_session' 77 ); 78 if (!session) throw Error('missing genuine original private session'); 79 const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock'); 80 if (!unlocked) throw Error('missing genuine original unlock'); 81 const initial = (await f.row())!; 82 const originalOutbox = JSON.stringify(initial.record); 83 const ownerSecret = new Uint8Array(32).fill(83), 84 outerSecret = new Uint8Array(32).fill(86), 85 strangerSecret = new Uint8Array(32).fill(85); 86 const stranger = getPublicKey(strangerSecret), 87 disposable = getPublicKey(outerSecret); 88 function encrypt(secret: Uint8Array, target: string, plain: string) { 89 const key = nip44.v2.utils.getConversationKey(secret, target); 90 try { 91 return nip44.v2.encrypt(plain, key); 92 } finally { 93 key.fill(0); 94 } 95 } 96 let sealWire: string; 97 try { 98 if (unknownSender) { 99 const template = { 100 pubkey: stranger, 101 kind: 14, 102 created_at: 1700000000, 103 tags: [['p', f.owner]], 104 content: 'Controlled unknown authenticated sender' 105 }; 106 const rumor = { id: getEventHash(template), ...template }; 107 sealWire = JSON.stringify( 108 finalizeEvent( 109 { 110 kind: 13, 111 created_at: 1699999900, 112 tags: [], 113 content: encrypt(strangerSecret, f.owner, JSON.stringify(rumor)) 114 }, 115 strangerSecret 116 ) 117 ); 118 } else { 119 const outer = JSON.parse(initial.record.self.wire) as { 120 pubkey: string; 121 content: string; 122 }; 123 const key = nip44.v2.utils.getConversationKey(ownerSecret, outer.pubkey); 124 try { 125 sealWire = nip44.v2.decrypt(outer.content, key); 126 } finally { 127 key.fill(0); 128 } 129 } 130 for (let i = 0; i < count; i++) { 131 const outer = finalizeEvent( 132 { 133 kind: 1059, 134 created_at: 1700000000 + i, 135 tags: [['p', f.owner]], 136 content: encrypt(outerSecret, f.owner, sealWire) 137 }, 138 outerSecret 139 ); 140 const admitted = admitInboxEnvelope( 141 JSON.stringify(outer), 142 f.owner, 143 'wss://archive.example.org', 144 100 + i 145 ); 146 if ( 147 !admitted || 148 (await retainInboxEnvelope(f.repository, session, admitted)).status !== 149 'retained' 150 ) 151 throw Error('missing actual retained ciphertext'); 152 } 153 } finally { 154 ownerSecret.fill(0); 155 outerSecret.fill(0); 156 strangerSecret.fill(0); 157 } 158 const publicStore = getPublicStore()!; 159 async function retained() { 160 const rows = await listPrivateReceivedRecords(f.repository); 161 if (!rows.ok) throw Error('actual received scan failed'); 162 return rows.value.map((row) => 163 privateRecordWire(row, f.owner, privateRecordIdentity(row)?.id) 164 ); 165 } 166 const originalReceived = JSON.stringify(await retained()), 167 baseline = f.counts(); 168 let queue: DecryptionQueue | undefined; 169 let warmReader: ReceivedUnwrap | undefined; 170 const blocks = privateBlocksForIdentity(f.identity); 171 if (!blocks) throw Error('original native preference owner unavailable'); 172 const preferences = blocks; 173 return { 174 ...f, 175 stranger, 176 disposable, 177 async persistInnerBlock() { 178 await mountLocalPrivateBlocks(preferences); 179 const rows = await listPrivateReceivedRecords(f.repository); 180 const record = 181 rows.ok && rows.value[0] && privateRecordIdentity(rows.value[0]); 182 if (!record) throw Error('original opaque ciphertext unavailable'); 183 warmReader = captureReceivedUnwrap( 184 f.repository, 185 f.identity, 186 record.id, 187 'reviewed_inbox_unlock' 188 ); 189 if (!warmReader) throw Error('original nested reader unavailable'); 190 const result = await unwrapReceivedEnvelope(warmReader); 191 const room = 192 result.status === 'authenticated' && 193 (admitReceivedConversation(result.envelope, 'inbound') ?? 194 admitReceivedConversation(result.envelope, 'self_archive')); 195 if (!room || acceptUnlockedConversation(unlocked, room) !== 'added') 196 throw Error('original inner room unavailable'); 197 return blockLocalPrivatePeer( 198 preferences, 199 room, 200 unlocked, 201 'reviewed_local_private_block' 202 ); 203 }, 204 undoInnerBlock: () => 205 undoLocalPrivatePeer( 206 preferences, 207 unknownSender ? stranger : f.peer, 208 'reviewed_local_private_undo' 209 ), 210 preferences: () => localPrivateBlocksSnapshot(preferences), 211 visibleRooms: () => 212 queue 213 ? decryptionQueueConversations(queue).map(conversationSnapshot) 214 : [], 215 capture(review: unknown = 'reviewed_inbox_unlock') { 216 queue = captureDecryptionQueue( 217 f.repository, 218 session, 219 f.identity, 220 unlocked, 221 review 222 ); 223 return !!queue; 224 }, 225 refresh: async () => queue && (await refreshDecryptionQueue(queue)), 226 batch: async ( 227 review: unknown = 'reviewed_decrypt_batch', 228 blocked: readonly string[] = [] 229 ) => queue && (await runDecryptionBatch(queue, review, blocked)), 230 snapshot: () => queue && decryptionQueueSnapshot(queue), 231 delta: () => ({ 232 decrypts: f.counts().decrypts - baseline.decrypts, 233 keys: f.counts().keys - baseline.keys, 234 signs: f.counts().signs - baseline.signs, 235 encrypts: f.counts().encrypts - baseline.encrypts 236 }), 237 cache: () => unlockedSessionSnapshot(unlocked), 238 messages: () => readUnlockedMessages(unlocked), 239 encryptedUnchanged: async () => 240 JSON.stringify(await retained()) === originalReceived && 241 JSON.stringify((await f.row())!.record) === originalOutbox, 242 count: async () => (await retained()).length, 243 publicContains: async () => { 244 const rows = await listPrivateReceivedRecords(f.repository); 245 return ( 246 rows.ok && 247 rows.value.some((row) => { 248 const wire = privateRecordWire( 249 row, 250 f.owner, 251 privateRecordIdentity(row)?.id 252 ); 253 return ( 254 wire && 255 publicStoreEnvelope( 256 publicStore, 257 (JSON.parse(wire) as { id: string }).id 258 ) !== undefined 259 ); 260 }) 261 ); 262 }, 263 forged: () => 264 runDecryptionBatch({} as DecryptionQueue, 'reviewed_decrypt_batch'), 265 copied: () => 266 queue && runDecryptionBatch({ ...queue }, 'reviewed_decrypt_batch'), 267 stop: () => { 268 if (queue) stopDecryptionQueue(queue); 269 }, 270 expire: () => { 271 if (queue) expireDecryptionQueueWait(queue); 272 }, 273 closeUnlock: () => closeUnlockedSession(unlocked), 274 scheduler: () => { 275 const sdk = browserExtensionScheduler(); 276 return sdk && extensionSchedulerSnapshot(sdk); 277 }, 278 identitySnapshot: () => identitySessionSnapshot(f.identity), 279 async foreignCapture() { 280 const other = createIdentitySession(); 281 await connectIdentity(other); 282 await probeIdentityMessaging(other, 'reviewed_self_copy'); 283 const before = f.counts(); 284 const candidate = captureDecryptionQueue( 285 f.repository, 286 session, 287 other, 288 unlocked, 289 'reviewed_inbox_unlock' 290 ); 291 const after = f.counts(); 292 disconnectIdentity(other); 293 return { 294 captured: !!candidate, 295 keys: after.keys - before.keys, 296 decrypts: after.decrypts - before.decrypts, 297 signs: after.signs - before.signs 298 }; 299 }, 300 competing: async () => { 301 const sdk = browserExtensionScheduler(), 302 ownership = identityMessagingOwnership(f.identity); 303 return ( 304 sdk && 305 ownership && 306 (await runExtensionAction( 307 sdk, 308 { 309 owner: ownership.owner, 310 session: ownership.session, 311 operation: Symbol() 312 }, 313 ownership.current, 314 () => Promise.resolve(true) 315 )) 316 ); 317 }, 318 close() { 319 if (warmReader) stopReceivedUnwrap(warmReader); 320 if (queue) stopDecryptionQueue(queue); 321 closePrivateSession(session); 322 f.close(); 323 } 324 }; 325 }