self-recovery.ts (6687B)
1 import { makeFixture as makeCryptoFixture } from './giftwrap-builder.ts'; 2 import { 3 openBrowserDatabase, 4 closeBrowserDatabase, 5 browserDatabaseTransaction 6 } from '../../../src/lib/persistence/database.ts'; 7 import { createPrivateStorageRepository } from '../../../src/lib/persistence/private-storage.ts'; 8 import { reservedSendSnapshot } from '../../../src/lib/messaging/send-identity.ts'; 9 import { 10 captureEnvelopePreparation, 11 prepareEnvelopeRole, 12 preparedEnvelopeProof, 13 closeEnvelopePreparation 14 } from '../../../src/lib/messaging/envelope-preparation.ts'; 15 import { 16 commitSelfRecovery, 17 selfRecoveryAcknowledgementSnapshot 18 } from '../../../src/lib/persistence/private-sends.ts'; 19 import { 20 captureSelfRecoveryPreparation, 21 prepareSelfRecovery, 22 selfRecoveryPreparationSnapshot, 23 preparedSelfRecovery, 24 selfRecoveryPeerPreparation, 25 stopSelfRecoveryPreparation 26 } from '../../../src/lib/messaging/prepare-send.ts'; 27 export { 28 commitSelfRecovery, 29 selfRecoveryAcknowledgementSnapshot, 30 captureSelfRecoveryPreparation, 31 prepareSelfRecovery, 32 selfRecoveryPreparationSnapshot, 33 preparedSelfRecovery, 34 selfRecoveryPeerPreparation, 35 stopSelfRecoveryPreparation 36 }; 37 // Source-only genuine stock SDK plus actual Chromium IDB/Web Locks. Neither 38 // this disposable provider nor these synthetic faults qualify an operator. 39 export async function makeFixture() { 40 const marker = 'HCP081_PRIVATE_TEXT_MEMORY_ONLY_SENTINEL'; 41 const cryptoFixture = await makeCryptoFixture(marker); 42 const opened = await openBrowserDatabase(); 43 if (opened.state !== 'ready') throw Error('self storage unavailable'); 44 const database = opened.owner, 45 repository = createPrivateStorageRepository(database, cryptoFixture.owner), 46 foreignRepository = createPrivateStorageRepository( 47 database, 48 cryptoFixture.peer 49 ); 50 if (!repository || !foreignRepository) 51 throw Error('self storage namespace missing'); 52 const preparation = captureSelfRecoveryPreparation( 53 repository, 54 cryptoFixture.identity, 55 cryptoFixture.reserved, 56 'reviewed_self_recovery' 57 ); 58 if (!preparation) throw Error('self preparation missing'); 59 let restore = () => {}, 60 releaseLock: (() => void) | undefined; 61 const pairs = new Set<ReturnType<typeof captureEnvelopePreparation>>(); 62 async function proof(role: 'self' | 'peer') { 63 const pair = captureEnvelopePreparation( 64 cryptoFixture.identity, 65 cryptoFixture.reserved, 66 'reviewed_envelope_pair' 67 ); 68 if (!pair) throw Error('crypto pair missing'); 69 pairs.add(pair); 70 if ( 71 (await prepareEnvelopeRole(pair, 'self', 'reviewed_pair_role')).status !== 72 'prepared' || 73 (role === 'peer' && 74 (await prepareEnvelopeRole(pair, 'peer', 'reviewed_pair_role')) 75 .status !== 'complete') 76 ) 77 throw Error('role proof missing'); 78 const proof = preparedEnvelopeProof(pair, role); 79 if (!proof) throw Error('peer proof missing'); 80 return proof; 81 } 82 // The queued write and transaction are real. In unknown mode the fixture 83 // loses its acknowledgement after the actual put, then makes abort fail; 84 // actual completion/readback determine whether the original ciphertext exists. 85 function fault(mode: 'abort' | 'unknown') { 86 restore(); 87 const put = Reflect.get<IDBObjectStore, 'put'>( 88 IDBObjectStore.prototype, 89 'put' 90 ), 91 abort = Reflect.get<IDBTransaction, 'abort'>( 92 IDBTransaction.prototype, 93 'abort' 94 ); 95 let hits = 0; 96 const affected = new WeakSet<IDBTransaction>(); 97 IDBObjectStore.prototype.put = function ( 98 value: unknown, 99 key?: IDBValidKey 100 ) { 101 const request = 102 key === undefined ? put.call(this, value) : put.call(this, value, key); 103 if (this.name === 'private_sends' && hits === 0) { 104 hits++; 105 if (mode === 'abort') abort.call(this.transaction); 106 else { 107 affected.add(this.transaction); 108 throw Error('controlled lost acknowledgement'); 109 } 110 } 111 return request; 112 }; 113 IDBTransaction.prototype.abort = function () { 114 if (affected.has(this)) throw Error('controlled abort unavailable'); 115 return abort.call(this); 116 }; 117 restore = () => { 118 IDBObjectStore.prototype.put = put; 119 IDBTransaction.prototype.abort = abort; 120 }; 121 return () => hits; 122 } 123 async function holdOwner() { 124 let entered: (() => void) | undefined; 125 const ready = new Promise<void>((resolve) => { 126 entered = resolve; 127 }); 128 const held = navigator.locks.request( 129 'harvestcircle:owner:' + cryptoFixture.owner, 130 async () => { 131 entered?.(); 132 await new Promise<void>((resolve) => { 133 releaseLock = resolve; 134 }); 135 } 136 ); 137 await ready; 138 return () => { 139 releaseLock?.(); 140 return held; 141 }; 142 } 143 async function publicDraftRows() { 144 const tx = browserDatabaseTransaction( 145 database, 146 ['public_drafts'], 147 'readonly' 148 ), 149 request = tx.objectStore('public_drafts').getAll(); 150 return new Promise<string>((resolve, reject) => { 151 tx.addEventListener('complete', () => 152 resolve(JSON.stringify(request.result)) 153 ); 154 tx.addEventListener('abort', () => reject(Error('inspection aborted'))); 155 }); 156 } 157 async function corruptReservation() { 158 const record = reservedSendSnapshot(cryptoFixture.reserved); 159 if (!record) throw Error('missing original reservation'); 160 const tx = browserDatabaseTransaction( 161 database, 162 ['private_sends'], 163 'readwrite' 164 ); 165 tx.objectStore('private_sends').put({ 166 owner: record.owner, 167 id: record.id, 168 wire: '{"schema":999}' 169 }); 170 await new Promise<void>((resolve, reject) => { 171 tx.addEventListener('complete', () => resolve()); 172 tx.addEventListener('abort', () => 173 reject(Error('fixture write aborted')) 174 ); 175 }); 176 } 177 return { 178 ...cryptoFixture, 179 marker, 180 database, 181 repository, 182 foreignRepository, 183 preparation, 184 fault, 185 peerProof: () => proof('peer'), 186 selfProof: () => proof('self'), 187 holdOwner, 188 publicDraftRows, 189 corruptReservation, 190 closePeerPreparation: closeEnvelopePreparation, 191 pendingEncryption: () => { 192 const slot = cryptoFixture.slot(); 193 return slot?.state === 'active' && slot.pending === 'encrypt'; 194 }, 195 closeStorage: () => closeBrowserDatabase(database), 196 close() { 197 restore(); 198 releaseLock?.(); 199 stopSelfRecoveryPreparation(preparation); 200 for (const pair of pairs) if (pair) closeEnvelopePreparation(pair); 201 closeBrowserDatabase(database); 202 cryptoFixture.close(); 203 } 204 }; 205 }