seal-builder.ts (10204B)
1 import { 2 finalizeEvent, 3 generateSecretKey, 4 getPublicKey, 5 verifiedSymbol, 6 type UnsignedEvent 7 } from 'applesauce-core/helpers'; 8 import { nip44 } from 'applesauce-core/helpers/encryption'; 9 import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts'; 10 import { captureEnquiryContext } from '../../../src/lib/messaging/enquiry-context.ts'; 11 import { captureEnquiryRumor } from '../../../src/lib/messaging/rumor-plan.ts'; 12 import { 13 openBrowserDatabase, 14 closeBrowserDatabase, 15 browserDatabaseTransaction 16 } from '../../../src/lib/persistence/database.ts'; 17 import { createPrivateSendReservationRepository } from '../../../src/lib/persistence/private-send-reservations.ts'; 18 import { 19 reserveSendIdentity, 20 reservedSendRumorWire 21 } from '../../../src/lib/messaging/send-identity.ts'; 22 import { 23 createIdentitySession, 24 connectIdentity, 25 probeIdentityMessaging, 26 identitySessionSnapshot, 27 disconnectIdentity 28 } from '../../../src/lib/runtime/identity-session.ts'; 29 import { 30 capturePrivateSealOperation, 31 buildPrivateSeal, 32 stopPrivateSeal, 33 expirePrivateSealWait, 34 privateSealSnapshot 35 } from '../../../src/lib/nostr/seal-builder.ts'; 36 import { 37 browserExtensionScheduler, 38 extensionSchedulerSnapshot 39 } from '../../../src/lib/nostr/extension-scheduler.ts'; 40 export { 41 capturePrivateSealOperation, 42 buildPrivateSeal, 43 stopPrivateSeal, 44 expirePrivateSealWait, 45 privateSealSnapshot 46 }; 47 export type Mode = 48 | 'normal' 49 | 'wrong_cipher' 50 | 'wrong_author' 51 | 'wrong_tags' 52 | 'wrong_time' 53 | 'cached_bad_id' 54 | 'missing' 55 | 'declined' 56 | 'changed_key' 57 | 'hold_encrypt' 58 | 'hold_sign' 59 | 'wrong_plaintext' 60 | 'declined_decrypt' 61 | 'hold_decrypt' 62 | 'getter_reentry' 63 | 'stop_capability_getter' 64 | 'stop_capability_after_key'; 65 // Ephemeral source-only provider: actual stock SDK encryption/signature and real 66 // Chromium IDB/WebLocks. No installed extension/relay/client qualification. 67 export async function makeFixture() { 68 const secret = generateSecretKey(), 69 peerSecret = generateSecretKey(), 70 owner = getPublicKey(secret), 71 peer = getPublicKey(peerSecret); 72 let mode: Mode = 'normal', 73 keys = 0, 74 encrypts = 0, 75 signs = 0, 76 decrypts = 0, 77 capabilityReads = 0, 78 reentrantReads = 0, 79 postStopEncrypts = 0, 80 getterStopped = false, 81 watched: ReturnType<typeof capturePrivateSealOperation>, 82 release: (() => void) | undefined; 83 function encryptTo(target: string, text: string) { 84 const conversation = nip44.v2.utils.getConversationKey(secret, target); 85 try { 86 return nip44.v2.encrypt(text, conversation); 87 } finally { 88 conversation.fill(0); 89 } 90 } 91 function sign(template: UnsignedEvent) { 92 const input = 93 mode === 'wrong_cipher' 94 ? { ...template, content: encryptTo(peer, 'different immutable rumor') } 95 : mode === 'wrong_tags' 96 ? { ...template, tags: [['client', 'leak']] } 97 : mode === 'wrong_time' 98 ? { ...template, created_at: template.created_at + 1 } 99 : template; 100 const signed = finalizeEvent( 101 input, 102 mode === 'wrong_author' ? peerSecret : secret 103 ); 104 return mode === 'cached_bad_id' 105 ? { ...signed, id: '0'.repeat(64), [verifiedSymbol]: true } 106 : { 107 ...signed, 108 plaintext: 'never retained sentinel', 109 toJSON: () => { 110 throw Error('unexpected provider conversion'); 111 } 112 }; 113 } 114 const provider = { 115 getPublicKey: () => { 116 keys++; 117 return Promise.resolve(mode === 'changed_key' ? peer : owner); 118 }, 119 signEvent: (template: UnsignedEvent) => { 120 signs++; 121 return mode === 'hold_sign' 122 ? new Promise<ReturnType<typeof sign>>((resolve) => { 123 release = () => resolve(sign(template)); 124 }) 125 : Promise.resolve(sign(template)); 126 }, 127 get nip44() { 128 capabilityReads++; 129 if ( 130 watched && 131 (mode === 'stop_capability_getter' || 132 (mode === 'stop_capability_after_key' && capabilityReads === 2)) 133 ) { 134 stopPrivateSeal(watched); 135 return undefined; 136 } 137 return mode === 'missing' 138 ? undefined 139 : { 140 get encrypt() { 141 const scheduler = browserExtensionScheduler(), 142 slot = scheduler && extensionSchedulerSnapshot(scheduler); 143 if ( 144 mode === 'getter_reentry' && 145 watched && 146 slot && 147 slot.state === 'active' && 148 slot.pending === 'encrypt' 149 ) { 150 reentrantReads++; 151 getterStopped = true; 152 stopPrivateSeal(watched); 153 } 154 return (target: string, text: string) => { 155 encrypts++; 156 if (getterStopped) postStopEncrypts++; 157 if (mode === 'declined') 158 return Promise.reject(Error('private failure must not leak')); 159 if (mode === 'hold_encrypt') 160 return new Promise<string>((resolve) => { 161 release = () => resolve(encryptTo(target, text)); 162 }); 163 return Promise.resolve( 164 encryptTo( 165 target, 166 mode === 'wrong_plaintext' ? 'substitute rumor' : text 167 ) 168 ); 169 }; 170 }, 171 decrypt: (target: string, cipher: string) => { 172 decrypts++; 173 if (mode === 'declined_decrypt') 174 return Promise.reject(Error('decrypt refused')); 175 const decryptNow = () => { 176 const conversation = nip44.v2.utils.getConversationKey( 177 secret, 178 target 179 ); 180 try { 181 return nip44.v2.decrypt(cipher, conversation); 182 } finally { 183 conversation.fill(0); 184 } 185 }; 186 if (mode === 'hold_decrypt') 187 return new Promise<string>((resolve) => { 188 release = () => resolve(decryptNow()); 189 }); 190 return Promise.resolve(decryptNow()); 191 } 192 }; 193 } 194 }; 195 Object.defineProperty(window, 'nostr', { 196 configurable: true, 197 value: provider 198 }); 199 const identity = createIdentitySession(); 200 await connectIdentity(identity); 201 await probeIdentityMessaging(identity, 'reviewed_self_copy'); 202 const food = finalizeEvent( 203 { 204 kind: 30402, 205 created_at: 1700000060, 206 content: 'Public carrots', 207 tags: [ 208 ['d', 'carrots'], 209 ['title', 'Carrots'], 210 ['summary', 'Fresh carrots'], 211 ['published_at', '1700000000'], 212 ['location', 'Victoria'], 213 ['price', '3.5', 'CAD'], 214 ['radroots:price_unit', 'lb'], 215 ['status', 'active'] 216 ] 217 }, 218 peerSecret 219 ); 220 const proof = verifyEnvelope(JSON.stringify(food)); 221 if (!proof.ok) throw Error('invalid public fixture'); 222 const context = captureEnquiryContext(proof.value); 223 if (!context) throw Error('invalid context'); 224 const reservationTime = Date.now(); 225 const plan = captureEnquiryRumor( 226 identity, 227 context, 228 'Private seal sentinel', 229 Math.floor(reservationTime / 1000) 230 ); 231 if (!plan) throw Error('missing plan'); 232 const opened = await openBrowserDatabase(); 233 if (opened.state !== 'ready') throw Error('missing database'); 234 const database = opened.owner, 235 repository = createPrivateSendReservationRepository(database, owner); 236 if (!repository) throw Error('missing repository'); 237 // Controlled fixture second across actual asynchronous IDB/WebLock setup. 238 // Production admission still requires its real current observed second. 239 const liveNow = Date.now; 240 let reservation: Awaited<ReturnType<typeof reserveSendIdentity>>; 241 Date.now = () => reservationTime; 242 try { 243 reservation = await reserveSendIdentity( 244 repository, 245 identity, 246 '12345678-1234-4234-8234-123456789abc', 247 plan, 248 'reviewed_private_intent' 249 ); 250 } finally { 251 Date.now = liveNow; 252 } 253 if (reservation.status !== 'reserved') 254 throw Error('missing reservation: ' + reservation.status); 255 const reserved = reservation.identity; 256 const original = reservedSendRumorWire(reserved); 257 return { 258 owner, 259 peer, 260 identity, 261 reserved, 262 operation: ( 263 role: unknown = 'peer', 264 review: unknown = 'reviewed_private_seal' 265 ) => { 266 watched = capturePrivateSealOperation(identity, reserved, role, review); 267 return watched; 268 }, 269 mode: (value: Mode) => { 270 mode = value; 271 capabilityReads = 0; 272 }, 273 counts: () => ({ 274 keys, 275 encrypts, 276 decrypts, 277 signs, 278 reentrantReads, 279 postStopEncrypts 280 }), 281 identityState: () => identitySessionSnapshot(identity).state, 282 settle: () => { 283 release?.(); 284 }, 285 slot: () => { 286 const scheduler = browserExtensionScheduler(); 287 return scheduler ? extensionSchedulerSnapshot(scheduler) : undefined; 288 }, 289 disconnect: () => disconnectIdentity(identity), 290 async stored() { 291 const tx = browserDatabaseTransaction( 292 database, 293 ['private_sends'], 294 'readonly' 295 ), 296 request = tx.objectStore('private_sends').getAll(); 297 return await new Promise<string>((resolve, reject) => { 298 tx.addEventListener('complete', () => 299 resolve(JSON.stringify(request.result)) 300 ); 301 tx.addEventListener('abort', () => reject(Error('inspection aborted'))); 302 }); 303 }, 304 decrypt(wire: string, role: 'peer' | 'self') { 305 const seal = JSON.parse(wire) as { content: string }; 306 const conversation = nip44.v2.utils.getConversationKey( 307 role === 'peer' ? peerSecret : secret, 308 owner 309 ); 310 try { 311 return { 312 equal: nip44.v2.decrypt(seal.content, conversation) === original, 313 seal 314 }; 315 } finally { 316 conversation.fill(0); 317 } 318 }, 319 close() { 320 disconnectIdentity(identity); 321 closeBrowserDatabase(database); 322 secret.fill(0); 323 peerSecret.fill(0); 324 delete window.nostr; 325 } 326 }; 327 }