app

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

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 }