private-store.test.ts (12035B)
1 import { test } from 'node:test'; 2 import assert from 'node:assert/strict'; 3 import { 4 finalizeEvent, 5 EncryptedContentSymbol, 6 verifiedSymbol 7 } from 'applesauce-core/helpers'; 8 import { 9 createIdentitySession, 10 connectIdentity, 11 probeIdentityMessaging, 12 disconnectIdentity, 13 recheckIdentityOwner 14 } from '../../src/lib/runtime/identity-session.ts'; 15 import { createPrivateSession } from '../../src/lib/runtime/private-session.ts'; 16 import { 17 getPrivateStore, 18 insertPrivateEnvelope, 19 privateStoreEnvelope, 20 privateStoreSnapshot 21 } from '../../src/lib/messaging/private-store.ts'; 22 import { 23 getPrivateCacheScope, 24 retainPrivateCacheWire, 25 privateCacheWire, 26 privateCacheSnapshot, 27 clearPrivateCacheScope, 28 closePrivateCacheScope 29 } from '../../src/lib/nostr/private-cache-scope.ts'; 30 import { 31 verifyEnvelope, 32 verifiedEnvelopeSnapshot 33 } from '../../src/lib/nostr/verified-envelope.ts'; 34 import { 35 getPublicStore, 36 insertPublicEnvelope, 37 publicStoreEnvelope, 38 closePublicStore 39 } from '../../src/lib/nostr/public-store.ts'; 40 41 // HC_TEST_ONLY_PROVIDER: genuine SDK ownership; echo probe is not encryption qualification. 42 await test('disposable private store and synthetic ownership cache follow genuine SDK session generations', async (t) => { 43 const owner = 44 '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'; 45 const other = 46 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5'; 47 assert.equal(typeof window, 'undefined'); 48 assert.equal(getPrivateStore({} as never), undefined); 49 let key = owner, 50 prompts = 0; 51 Object.defineProperty(globalThis, 'window', { 52 configurable: true, 53 value: { 54 nostr: { 55 getPublicKey: () => { 56 prompts++; 57 return Promise.resolve(key); 58 }, 59 signEvent: () => 60 Promise.reject(new Error('HC_TEST_ONLY_UNEXPECTED_SIGN')), 61 nip44: { 62 encrypt: (_peer: string, text: string) => 63 Promise.resolve('fixture:' + text), 64 decrypt: (_peer: string, text: string) => 65 Promise.resolve(text.slice(8)) 66 } 67 } 68 } 69 }); 70 const identity = createIdentitySession(); 71 function signed( 72 kind: number, 73 tags: string[][] = [], 74 content = 'HC_TEST_ONLY_CIPHERTEXT' 75 ) { 76 const ephemeral = crypto.getRandomValues(new Uint8Array(32)); 77 try { 78 return JSON.stringify( 79 finalizeEvent( 80 { kind, tags, content, created_at: 1700000060 }, 81 ephemeral 82 ) 83 ); 84 } finally { 85 ephemeral.fill(0); 86 } 87 } 88 function proof(wire: string) { 89 const r = verifyEnvelope(wire); 90 assert.ok(r.ok); 91 return r.value; 92 } 93 async function connect() { 94 assert.equal((await connectIdentity(identity)).state, 'signing_only'); 95 assert.equal( 96 (await probeIdentityMessaging(identity, 'reviewed_self_copy')).state, 97 'messaging_capable' 98 ); 99 const session = await createPrivateSession( 100 identity, 101 'reviewed_private_session' 102 ); 103 assert.ok(session); 104 return session; 105 } 106 let publicStore: ReturnType<typeof getPublicStore>; 107 try { 108 await t.test( 109 'guest and forged browser sessions cannot acquire owned state', 110 () => { 111 assert.throws( 112 () => getPrivateStore({} as never), 113 /private_session_invalid/ 114 ); 115 assert.throws( 116 () => getPrivateCacheScope({} as never, 'projection_ownership'), 117 /private_session_invalid/ 118 ); 119 assert.equal(prompts, 0); 120 } 121 ); 122 const session = await connect(); 123 const store = getPrivateStore(session); 124 assert.ok(store); 125 const cache = getPrivateCacheScope(session, 'projection_ownership'); 126 assert.ok(cache); 127 const outer = proof(signed(1059, [['p', owner]])); 128 const id = verifiedEnvelopeSnapshot(outer)!.id; 129 await t.test( 130 'verified owner-addressed ciphertext is isolated, immutable and duplicate-safe', 131 () => { 132 assert.equal(getPrivateStore(session), store); 133 assert.equal(insertPrivateEnvelope(store, outer), 'accepted'); 134 assert.equal(insertPrivateEnvelope(store, outer), 'duplicate'); 135 const view = verifiedEnvelopeSnapshot(privateStoreEnvelope(store, id)!); 136 assert.ok(view); 137 view.content = 'HC_TEST_ONLY_MUTATION'; 138 view.tags[0][1] = other; 139 assert.equal( 140 verifiedEnvelopeSnapshot(privateStoreEnvelope(store, id)!)!.content, 141 'HC_TEST_ONLY_CIPHERTEXT' 142 ); 143 assert.equal(privateStoreSnapshot(store).count, 1); 144 publicStore = getPublicStore(); 145 assert.ok(publicStore); 146 assert.equal(insertPublicEnvelope(publicStore, outer), 'not_public'); 147 assert.equal(publicStoreEnvelope(publicStore, id), undefined); 148 } 149 ); 150 await t.test( 151 'private kind, exact routing and original outer metadata boundaries reject before retention', 152 () => { 153 for (const kind of [0, 13, 14, 30402, 22242]) 154 assert.equal( 155 insertPrivateEnvelope(store, proof(signed(kind, [['p', owner]]))), 156 'rejected' 157 ); 158 for (const tags of [ 159 [], 160 [['p', other]], 161 [['p', owner, 'hint']], 162 [ 163 ['p', owner], 164 ['p', owner] 165 ], 166 [ 167 ['p', owner], 168 ['subject', 'private'] 169 ], 170 [ 171 ['p', owner], 172 ['client', 'private'] 173 ], 174 [ 175 ['p', owner], 176 ['e', id] 177 ] 178 ]) 179 assert.equal( 180 insertPrivateEnvelope(store, proof(signed(1059, tags))), 181 'rejected' 182 ); 183 assert.equal(insertPrivateEnvelope(store, {} as never), 'rejected'); 184 assert.equal( 185 insertPrivateEnvelope( 186 store, 187 proof(signed(1059, [['p', owner]], 'x'.repeat(32768))) 188 ), 189 'rejected' 190 ); 191 assert.equal(privateStoreSnapshot(store).count, 1); 192 } 193 ); 194 await t.test( 195 'imported decrypted and verified symbols cannot gain trust or cross retained signed fields', 196 () => { 197 const dirty = JSON.parse(signed(1059, [['p', owner]])) as Record< 198 string | symbol, 199 unknown 200 >; 201 dirty.decrypted = 'HC_TEST_ONLY_IMPORTED_PREVIEW'; 202 dirty[EncryptedContentSymbol] = { 203 body: 'HC_TEST_ONLY_IMPORTED_HELPER' 204 }; 205 dirty[verifiedSymbol] = true; 206 assert.equal(insertPrivateEnvelope(store, dirty as never), 'rejected'); 207 const token = proof(JSON.stringify(dirty)); 208 assert.equal(insertPrivateEnvelope(store, token), 'accepted'); 209 const clean = verifiedEnvelopeSnapshot( 210 privateStoreEnvelope(store, verifiedEnvelopeSnapshot(token)!.id)! 211 ); 212 assert.ok(clean); 213 assert.equal('decrypted' in clean, false); 214 assert.deepEqual(Object.getOwnPropertySymbols(clean), []); 215 } 216 ); 217 await t.test( 218 'synthetic projection ownership is bounded JSON memory, never validated message admission', 219 () => { 220 const k = 'f'.repeat(64), 221 wire = JSON.stringify({ body: 'HC_TEST_ONLY_SYNTHETIC_OWNERSHIP' }); 222 assert.equal(retainPrivateCacheWire(cache, k, wire), 'accepted'); 223 assert.equal(retainPrivateCacheWire(cache, k, wire), 'duplicate'); 224 assert.equal(retainPrivateCacheWire(cache, k, '{}'), 'conflict'); 225 assert.equal(privateCacheWire(cache, k), wire); 226 assert.equal( 227 retainPrivateCacheWire(cache, 'e'.repeat(64), { 228 [EncryptedContentSymbol]: 'HC_TEST_ONLY_HELPER' 229 }), 230 'rejected' 231 ); 232 assert.equal( 233 retainPrivateCacheWire(cache, 'e'.repeat(64), 'x'.repeat(32769)), 234 'rejected' 235 ); 236 clearPrivateCacheScope(cache); 237 assert.equal(privateCacheWire(cache, k), undefined); 238 for (let i = 0; i < 2000; i++) 239 assert.equal( 240 retainPrivateCacheWire( 241 cache, 242 i.toString(16).padStart(64, '0'), 243 '{}' 244 ), 245 'accepted' 246 ); 247 assert.equal( 248 retainPrivateCacheWire(cache, 'd'.repeat(64), '{}'), 249 'limit' 250 ); 251 assert.equal(privateCacheSnapshot(cache).count, 2000); 252 clearPrivateCacheScope(cache); 253 const payload = JSON.stringify('x'.repeat(32766)); 254 assert.equal(new TextEncoder().encode(payload).length, 32768); 255 for (let i = 0; i < 1536; i++) 256 assert.equal( 257 retainPrivateCacheWire( 258 cache, 259 i.toString(16).padStart(64, '0'), 260 payload 261 ), 262 'accepted' 263 ); 264 assert.equal(privateCacheSnapshot(cache).bytes, 50331648); 265 assert.equal( 266 retainPrivateCacheWire(cache, 'd'.repeat(64), '0'), 267 'limit' 268 ); 269 assert.equal(privateCacheSnapshot(cache).bytes, 50331648); 270 clearPrivateCacheScope(cache); 271 assert.equal( 272 retainPrivateCacheWire(cache, 'f'.repeat(64), wire), 273 'accepted' 274 ); 275 } 276 ); 277 await t.test( 278 'disconnect discards all owned raw and synthetic preview references and late writes', 279 () => { 280 const late = '{"body":"HC_TEST_ONLY_LATE_OWNERSHIP"}'; 281 const originalParse = JSON.parse.bind(JSON); 282 const savedParse = JSON.parse; 283 JSON.parse = (...args: Parameters<typeof JSON.parse>) => { 284 const value: unknown = originalParse(...args); 285 if (args[0] === late) disconnectIdentity(identity); 286 return value; 287 }; 288 try { 289 assert.equal( 290 retainPrivateCacheWire(cache, 'c'.repeat(64), late), 291 'closed' 292 ); 293 } finally { 294 JSON.parse = savedParse; 295 } 296 assert.equal(privateStoreEnvelope(store, id), undefined); 297 assert.deepEqual(privateStoreSnapshot(store), { 298 closed: true, 299 count: 0, 300 bytes: 0 301 }); 302 assert.equal(insertPrivateEnvelope(store, outer), 'closed'); 303 assert.equal(privateCacheWire(cache, 'f'.repeat(64)), undefined); 304 assert.deepEqual(privateCacheSnapshot(cache), { 305 closed: true, 306 count: 0, 307 bytes: 0 308 }); 309 assert.equal( 310 retainPrivateCacheWire(cache, 'a'.repeat(64), '{}'), 311 'closed' 312 ); 313 closePrivateCacheScope(cache); 314 } 315 ); 316 await t.test( 317 'same-author reconnect cannot revive old store or preview; account replacement remains isolated', 318 async () => { 319 const again = await connect(); 320 assert.notEqual(again, session); 321 const next = getPrivateStore(again); 322 assert.ok(next); 323 assert.notEqual(next, store); 324 assert.equal(privateStoreEnvelope(next, id), undefined); 325 assert.equal( 326 privateCacheWire( 327 getPrivateCacheScope(again, 'projection_ownership')!, 328 'f'.repeat(64) 329 ), 330 undefined 331 ); 332 key = other; 333 assert.equal((await recheckIdentityOwner(identity)).state, 'guest'); 334 assert.equal(privateStoreSnapshot(next).closed, true); 335 const changed = await connect(); 336 const foreign = getPrivateStore(changed); 337 assert.ok(foreign); 338 assert.equal(privateStoreEnvelope(foreign, id), undefined); 339 assert.equal(insertPrivateEnvelope(foreign, outer), 'rejected'); 340 assert.equal(privateStoreEnvelope(store, id), undefined); 341 assert.ok(publicStore); 342 const publicToken = proof(signed(0, [], '{}')); 343 const publicId = verifiedEnvelopeSnapshot(publicToken)!.id; 344 assert.equal( 345 insertPublicEnvelope(publicStore, publicToken), 346 'accepted' 347 ); 348 assert.ok(publicStoreEnvelope(publicStore, publicId)); 349 } 350 ); 351 } finally { 352 disconnectIdentity(identity); 353 if (publicStore) closePublicStore(publicStore); 354 Reflect.deleteProperty(globalThis, 'window'); 355 } 356 });