app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

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 });