app

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

message-metadata.ts (19381B)


      1 import {
      2   captureMessageMetadata,
      3   messageMetadataSnapshot,
      4   markDisplayedMessage,
      5   type MessageMetadata,
      6   MESSAGE_METADATA_DISCLOSURE
      7 } from '../../../src/lib/persistence/message-metadata.ts';
      8 import { readLocalUnread } from '../../../src/lib/messaging/unread.ts';
      9 import {
     10   openBrowserDatabase,
     11   closeBrowserDatabase,
     12   browserDatabaseTransaction,
     13   type BrowserDatabase
     14 } from '../../../src/lib/persistence/database.ts';
     15 import {
     16   captureUnlockedSession,
     17   acceptUnlockedConversation,
     18   readUnlockedMessages,
     19   unlockedSessionSnapshot,
     20   closeUnlockedSession,
     21   type UnlockedSession
     22 } from '../../../src/lib/messaging/unlocked-session.ts';
     23 import {
     24   getPrivateCacheScope,
     25   retainPrivateCacheWire,
     26   clearPrivateCacheScope,
     27   privateCacheSnapshot,
     28   type PrivateCacheScope
     29 } from '../../../src/lib/nostr/private-cache-scope.ts';
     30 import {
     31   createIdentitySession,
     32   connectIdentity,
     33   probeIdentityMessaging,
     34   disconnectIdentity,
     35   recheckIdentityOwner
     36 } from '../../../src/lib/runtime/identity-session.ts';
     37 import {
     38   getPublicKey,
     39   getEventHash,
     40   finalizeEvent,
     41   type UnsignedEvent
     42 } from 'applesauce-core/helpers';
     43 import { nip44 } from 'applesauce-core/helpers/encryption';
     44 import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts';
     45 import {
     46   createPrivateSession,
     47   closePrivateSession
     48 } from '../../../src/lib/runtime/private-session.ts';
     49 import {
     50   admitInboxEnvelope,
     51   retainInboxEnvelope
     52 } from '../../../src/lib/persistence/inbox-envelope-repository.ts';
     53 import {
     54   captureReceivedUnwrap,
     55   unwrapReceivedEnvelope,
     56   stopReceivedUnwrap,
     57   type ReceivedUnwrap,
     58   type ReceivedNestedEnvelope
     59 } from '../../../src/lib/nostr/unwrap-admission.ts';
     60 import {
     61   admitReceivedConversation,
     62   conversationSnapshot,
     63   type AdmittedConversation
     64 } from '../../../src/lib/messaging/admit-conversation.ts';
     65 type Scenario =
     66   | 'inbound'
     67   | 'self_archive'
     68   | 'third_party'
     69   | 'hostile_text'
     70   | 'missing_parent';
     71 export async function makeFixture(
     72   scenario: Scenario = 'inbound',
     73   initialise = true
     74 ) {
     75   const f = await makeRecoveryFixture(initialise),
     76     privateSession = await createPrivateSession(
     77       f.identity,
     78       'reviewed_private_session'
     79     );
     80   if (!privateSession) throw Error('missing genuine private session');
     81   const ownerSecret = new Uint8Array(32).fill(83),
     82     peerSecret = new Uint8Array(32).fill(84),
     83     outerSecret = new Uint8Array(32).fill(85),
     84     other = getPublicKey(outerSecret);
     85   const senderSecret = scenario === 'self_archive' ? ownerSecret : peerSecret,
     86     sender = getPublicKey(senderSecret),
     87     recipient =
     88       scenario === 'self_archive'
     89         ? f.peer
     90         : scenario === 'third_party'
     91           ? other
     92           : f.owner;
     93   const tags: string[][] = [['p', recipient]];
     94   if (scenario === 'hostile_text') tags.push(['subject', other]);
     95   if (scenario === 'missing_parent')
     96     tags.push(['e', 'a'.repeat(64), 'wss://untrusted.example.org']);
     97   const template: UnsignedEvent = {
     98       pubkey: sender,
     99       kind: 14,
    100       created_at: 1700000000,
    101       tags,
    102       content:
    103         scenario === 'hostile_text'
    104           ? `Contact ${other} https://untrusted.example.org`
    105           : 'Actual encrypted room fixture'
    106     },
    107     rumor = { id: getEventHash(template), ...template };
    108   function encrypt(key: Uint8Array, target: string, plain: string) {
    109     const conversation = nip44.v2.utils.getConversationKey(key, target);
    110     try {
    111       return nip44.v2.encrypt(plain, conversation);
    112     } finally {
    113       conversation.fill(0);
    114     }
    115   }
    116   const seal = finalizeEvent(
    117     {
    118       kind: 13,
    119       created_at: 1699999900,
    120       tags: [],
    121       content: encrypt(senderSecret, f.owner, JSON.stringify(rumor))
    122     },
    123     senderSecret
    124   );
    125   const outer = finalizeEvent(
    126     {
    127       kind: 1059,
    128       created_at: 1699999800,
    129       tags: [['p', f.owner]],
    130       content: encrypt(outerSecret, f.owner, JSON.stringify(seal))
    131     },
    132     outerSecret
    133   );
    134   ownerSecret.fill(0);
    135   peerSecret.fill(0);
    136   outerSecret.fill(0);
    137   const admitted = admitInboxEnvelope(
    138     JSON.stringify(outer),
    139     f.owner,
    140     'wss://archive.example.org',
    141     100
    142   );
    143   if (!admitted) throw Error('missing signed addressed outer');
    144   const saved = await retainInboxEnvelope(
    145     f.repository,
    146     privateSession,
    147     admitted
    148   );
    149   if (saved.status !== 'retained') throw Error('no actual retained cipher');
    150   let reader: ReceivedUnwrap | undefined,
    151     nested: ReceivedNestedEnvelope | undefined,
    152     room: AdmittedConversation | undefined;
    153   let unlocked: UnlockedSession | undefined;
    154   let rawCache: PrivateCacheScope | undefined;
    155   let database: BrowserDatabase | undefined,
    156     metadata: MessageMetadata | undefined;
    157   let otherMetadata: MessageMetadata | undefined;
    158   let otherPrivateSession: Awaited<ReturnType<typeof createPrivateSession>>;
    159   let otherIdentity: ReturnType<typeof createIdentitySession> | undefined;
    160   return {
    161     ...f,
    162     other,
    163     rumorId: rumor.id,
    164     async unlock() {
    165       reader = captureReceivedUnwrap(
    166         f.repository,
    167         f.identity,
    168         outer.id,
    169         'reviewed_inbox_unlock'
    170       );
    171       if (!reader) return 'invalid';
    172       const result = await unwrapReceivedEnvelope(reader);
    173       if (result.status === 'authenticated') nested = result.envelope;
    174       return result.status;
    175     },
    176     admit(role: unknown) {
    177       room = nested && admitReceivedConversation(nested, role);
    178       return room && conversationSnapshot(room);
    179     },
    180     snapshot() {
    181       return room && conversationSnapshot(room);
    182     },
    183     forged() {
    184       return admitReceivedConversation({} as ReceivedNestedEnvelope, 'inbound');
    185     },
    186     copied() {
    187       return room && conversationSnapshot({ ...room });
    188     },
    189     captureCache(review: unknown = 'reviewed_messages_unlock') {
    190       unlocked = captureUnlockedSession(privateSession, review);
    191       if (unlocked)
    192         rawCache = getPrivateCacheScope(privateSession, 'projection_ownership');
    193       return !!unlocked;
    194     },
    195     cache() {
    196       return unlocked && room
    197         ? acceptUnlockedConversation(unlocked, room)
    198         : 'rejected';
    199     },
    200     messages() {
    201       return unlocked && readUnlockedMessages(unlocked);
    202     },
    203     cacheSnapshot() {
    204       return unlocked && unlockedSessionSnapshot(unlocked);
    205     },
    206     rawCacheSnapshot() {
    207       return rawCache && privateCacheSnapshot(rawCache);
    208     },
    209     forgedCache() {
    210       return (
    211         unlocked &&
    212         acceptUnlockedConversation(unlocked, {} as AdmittedConversation)
    213       );
    214     },
    215     copiedCache() {
    216       return (
    217         unlocked && room && acceptUnlockedConversation(unlocked, { ...room })
    218       );
    219     },
    220     closeCache() {
    221       if (unlocked) closeUnlockedSession(unlocked);
    222     },
    223     closePrivate() {
    224       closePrivateSession(privateSession);
    225     },
    226     async changedOwner() {
    227       f.mode('changed_key');
    228       return await recheckIdentityOwner(f.identity);
    229     },
    230     async otherGeneration() {
    231       otherIdentity = createIdentitySession();
    232       await connectIdentity(otherIdentity);
    233       await probeIdentityMessaging(otherIdentity, 'reviewed_self_copy');
    234       otherPrivateSession = await createPrivateSession(
    235         otherIdentity,
    236         'reviewed_private_session'
    237       );
    238       if (!otherPrivateSession)
    239         throw Error('missing other genuine private session');
    240       const scope = captureUnlockedSession(
    241         otherPrivateSession,
    242         'reviewed_messages_unlock'
    243       );
    244       if (!scope || !room) throw Error('missing genuine scope/room');
    245       return {
    246         accepted: acceptUnlockedConversation(scope, room),
    247         snapshot: unlockedSessionSnapshot(scope)
    248       };
    249     },
    250     quota() {
    251       const scope = getPrivateCacheScope(
    252         privateSession,
    253         'projection_ownership'
    254       );
    255       if (!scope) throw Error('missing actual scoped cache');
    256       for (let i = 0; i < 2000; i++) {
    257         const result = retainPrivateCacheWire(
    258           scope,
    259           i.toString(16).padStart(64, '0'),
    260           '{}'
    261         );
    262         if (result !== 'accepted')
    263           throw Error('unexpected quota fixture result ' + result);
    264       }
    265       return 2000;
    266     },
    267     corruptCachedWire() {
    268       const scope = getPrivateCacheScope(
    269         privateSession,
    270         'projection_ownership'
    271       );
    272       if (!scope || !room) throw Error('missing actual cache');
    273       const snapshot = conversationSnapshot(room);
    274       if (!snapshot) throw Error('no current room');
    275       clearPrivateCacheScope(scope);
    276       return retainPrivateCacheWire(
    277         scope,
    278         snapshot.rumorId,
    279         JSON.stringify({
    280           ...snapshot,
    281           peer: other,
    282           content: 'HOSTILE_CACHE_POISON'
    283         })
    284       );
    285     },
    286     async captureMetadata(review: unknown = 'reviewed_local_message_metadata') {
    287       if (!database) {
    288         const opened = await openBrowserDatabase();
    289         if (opened.state !== 'ready')
    290           throw Error('actual metadata database unavailable');
    291         database = opened.owner;
    292       }
    293       if (!unlocked) return false;
    294       metadata = captureMessageMetadata(
    295         database,
    296         privateSession,
    297         unlocked,
    298         review
    299       );
    300       return !!metadata;
    301     },
    302     async unread() {
    303       return metadata && (await readLocalUnread(metadata));
    304     },
    305     async metadataSnapshot() {
    306       return metadata && (await messageMetadataSnapshot(metadata));
    307     },
    308     async display(review: unknown = 'displayed_message') {
    309       return metadata && room
    310         ? await markDisplayedMessage(metadata, room, review)
    311         : { status: 'invalid' };
    312     },
    313     async forgedDisplay() {
    314       return metadata
    315         ? await markDisplayedMessage(
    316             metadata,
    317             {} as AdmittedConversation,
    318             'displayed_message'
    319           )
    320         : { status: 'invalid' };
    321     },
    322     async copiedDisplay() {
    323       return metadata && room
    324         ? await markDisplayedMessage(metadata, { ...room }, 'displayed_message')
    325         : { status: 'invalid' };
    326     },
    327     disclosure() {
    328       return MESSAGE_METADATA_DISCLOSURE;
    329     },
    330     async rawMetadata() {
    331       if (!database) throw Error('no actual database');
    332       const tx = browserDatabaseTransaction(
    333         database,
    334         ['received_envelopes', 'conversations'],
    335         'readonly'
    336       );
    337       const received = tx.objectStore('received_envelopes').getAll(),
    338         pairs = tx.objectStore('conversations').getAll();
    339       return await new Promise<{ received: unknown[]; pairs: unknown[] }>(
    340         (resolve, reject) => {
    341           tx.addEventListener('complete', () =>
    342             resolve({ received: received.result, pairs: pairs.result })
    343           );
    344           tx.addEventListener('abort', () =>
    345             reject(Error('actual raw scan aborted'))
    346           );
    347         }
    348       );
    349     },
    350     async corruptPair() {
    351       if (!database) throw Error('no actual database');
    352       const tx = browserDatabaseTransaction(
    353         database,
    354         ['conversations'],
    355         'readwrite'
    356       );
    357       tx.objectStore('conversations').put({
    358         owner: f.owner,
    359         id: '12345678-1234-4234-8234-123456789abd',
    360         wire: JSON.stringify({
    361           schema: 1,
    362           family: 'conversation_handle',
    363           owner: f.owner,
    364           id: '12345678-1234-4234-8234-123456789abd',
    365           peer: f.peer,
    366           subject: 'FORBIDDEN_CONTEXT'
    367         })
    368       });
    369       await new Promise<void>((resolve, reject) => {
    370         tx.addEventListener('complete', () => resolve());
    371         tx.addEventListener('abort', () =>
    372           reject(Error('corruption fixture aborted'))
    373         );
    374       });
    375     },
    376     abortNextWrite() {
    377       const original = Object.getOwnPropertyDescriptor(
    378         IDBObjectStore.prototype,
    379         'put'
    380       )?.value as IDBObjectStore['put'];
    381       let consumed = false;
    382       IDBObjectStore.prototype.put = function (
    383         ...args: Parameters<typeof original>
    384       ) {
    385         const request = original.apply(this, args);
    386         if (this.name === 'received_envelopes' && !consumed) {
    387           consumed = true;
    388           this.transaction.abort();
    389         }
    390         return request;
    391       };
    392       return () => {
    393         IDBObjectStore.prototype.put = original;
    394       };
    395     },
    396     async otherOwnerMetadata() {
    397       f.mode('changed_key');
    398       otherIdentity = createIdentitySession();
    399       await connectIdentity(otherIdentity);
    400       await probeIdentityMessaging(otherIdentity, 'reviewed_self_copy');
    401       otherPrivateSession = await createPrivateSession(
    402         otherIdentity,
    403         'reviewed_private_session'
    404       );
    405       if (!database || !otherPrivateSession)
    406         throw Error('no genuine other owner');
    407       const scope = captureUnlockedSession(
    408         otherPrivateSession,
    409         'reviewed_messages_unlock'
    410       );
    411       if (!scope) throw Error('no genuine other cache');
    412       const m = captureMessageMetadata(
    413         database,
    414         otherPrivateSession,
    415         scope,
    416         'reviewed_local_message_metadata'
    417       );
    418       if (!m) throw Error('no genuine other metadata');
    419       otherMetadata = m;
    420       return await messageMetadataSnapshot(m);
    421     },
    422     async wrongGenerationMetadata() {
    423       otherIdentity = createIdentitySession();
    424       await connectIdentity(otherIdentity);
    425       await probeIdentityMessaging(otherIdentity, 'reviewed_self_copy');
    426       otherPrivateSession = await createPrivateSession(
    427         otherIdentity,
    428         'reviewed_private_session'
    429       );
    430       if (!database || !otherPrivateSession || !unlocked)
    431         throw Error('no genuine generation test');
    432       return !!captureMessageMetadata(
    433         database,
    434         otherPrivateSession,
    435         unlocked,
    436         'reviewed_local_message_metadata'
    437       );
    438     },
    439     async queuedLogout() {
    440       if (!metadata || !room) throw Error('no genuine current metadata/room');
    441       let release!: () => void, held!: () => void;
    442       const ready = new Promise<void>((r) => {
    443         held = r;
    444       });
    445       const blocker = navigator.locks.request(
    446         'harvestcircle:owner:' + f.owner,
    447         async () => {
    448           held();
    449           await new Promise<void>((r) => {
    450             release = r;
    451           });
    452         }
    453       );
    454       await ready;
    455       const pending = markDisplayedMessage(metadata, room, 'displayed_message');
    456       f.disconnect();
    457       release();
    458       await blocker;
    459       return await pending;
    460     },
    461     failNextReadback() {
    462       const original = Object.getOwnPropertyDescriptor(
    463         IDBIndex.prototype,
    464         'openCursor'
    465       )?.value as IDBIndex['openCursor'];
    466       let reads = 0;
    467       IDBIndex.prototype.openCursor = function (
    468         ...args: Parameters<typeof original>
    469       ) {
    470         if (
    471           this.objectStore.name === 'received_envelopes' &&
    472           this.objectStore.transaction.mode === 'readonly' &&
    473           ++reads === 2
    474         )
    475           throw new DOMException('actual readback failure', 'AbortError');
    476         return original.apply(this, args);
    477       };
    478       return () => {
    479         IDBIndex.prototype.openCursor = original;
    480       };
    481     },
    482     async raceNextWrite() {
    483       if (!database) throw Error('no database');
    484       const rows = await this.rawMetadata(),
    485         raw = (
    486           rows.received as { owner: string; id: string; wire: string }[]
    487         ).find((x) => x.owner === f.owner);
    488       if (!raw) throw Error('missing received race row');
    489       const record = JSON.parse(raw.wire) as {
    490         revision: number;
    491         sources: string[];
    492       };
    493       const wire = JSON.stringify({
    494         ...record,
    495         revision: record.revision + 1,
    496         sources: [...record.sources, 'wss://race.example.org']
    497       });
    498       const original = Object.getOwnPropertyDescriptor(
    499         IDBDatabase.prototype,
    500         'transaction'
    501       )?.value as IDBDatabase['transaction'];
    502       let injected = false;
    503       IDBDatabase.prototype.transaction = function (
    504         ...args: Parameters<typeof original>
    505       ) {
    506         const stores = args[0],
    507           mode = args[1];
    508         if (
    509           !injected &&
    510           mode === 'readwrite' &&
    511           Array.isArray(stores) &&
    512           stores.includes('received_envelopes')
    513         ) {
    514           injected = true;
    515           const rival = original.call(
    516             this,
    517             ['received_envelopes'],
    518             'readwrite'
    519           );
    520           rival.objectStore('received_envelopes').put({ ...raw, wire });
    521         }
    522         return original.apply(this, args);
    523       };
    524       return () => {
    525         IDBDatabase.prototype.transaction = original;
    526       };
    527     },
    528     foreignNavigationSession() {
    529       return otherPrivateSession;
    530     },
    531     navigationInputs() {
    532       return { privateSession, metadata, room };
    533     },
    534     async otherNavigationInputs() {
    535       await this.otherOwnerMetadata();
    536       return { privateSession: otherPrivateSession, metadata: otherMetadata };
    537     },
    538     async anotherWrap(lateOld = false, productText?: string) {
    539       const selectedTemplate = {
    540           ...template,
    541           created_at: 1,
    542           content: productText ?? 'Late old actual encrypted rumor'
    543         },
    544         selectedRumor = lateOld
    545           ? { id: getEventHash(selectedTemplate), ...selectedTemplate }
    546           : rumor;
    547       let selectedSeal = seal;
    548       if (lateOld) {
    549         const peer = new Uint8Array(32).fill(84);
    550         try {
    551           selectedSeal = finalizeEvent(
    552             {
    553               kind: 13,
    554               created_at: 1,
    555               tags: [],
    556               content: encrypt(peer, f.owner, JSON.stringify(selectedRumor))
    557             },
    558             peer
    559           );
    560         } finally {
    561           peer.fill(0);
    562         }
    563       }
    564 
    565       const key = new Uint8Array(32).fill(86);
    566       let next;
    567       try {
    568         next = finalizeEvent(
    569           {
    570             kind: 1059,
    571             created_at: 1699999799,
    572             tags: [['p', f.owner]],
    573             content: encrypt(key, f.owner, JSON.stringify(selectedSeal))
    574           },
    575           key
    576         );
    577       } finally {
    578         key.fill(0);
    579       }
    580       const candidate = admitInboxEnvelope(
    581         JSON.stringify(next),
    582         f.owner,
    583         'wss://archive.example.org',
    584         101
    585       );
    586       if (!candidate) throw Error('no second outer');
    587       const result = await retainInboxEnvelope(
    588         f.repository,
    589         privateSession,
    590         candidate
    591       );
    592       if (result.status !== 'retained') throw Error('no second retained outer');
    593       reader = captureReceivedUnwrap(
    594         f.repository,
    595         f.identity,
    596         next.id,
    597         'reviewed_inbox_unlock'
    598       );
    599       if (!reader) throw Error('no genuine second reader');
    600       const opened = await unwrapReceivedEnvelope(reader);
    601       if (opened.status !== 'authenticated')
    602         throw Error('no actual second decrypt');
    603       nested = opened.envelope;
    604       room = admitReceivedConversation(
    605         nested,
    606         scenario === 'self_archive' ? 'self_archive' : 'inbound'
    607       );
    608       return { outerId: next.id, rumorId: selectedRumor.id };
    609     },
    610     stop() {
    611       if (reader) stopReceivedUnwrap(reader);
    612     },
    613     close() {
    614       if (database) closeBrowserDatabase(database);
    615       if (unlocked) closeUnlockedSession(unlocked);
    616       if (otherPrivateSession) closePrivateSession(otherPrivateSession);
    617       if (otherIdentity) disconnectIdentity(otherIdentity);
    618       if (reader) stopReceivedUnwrap(reader);
    619       closePrivateSession(privateSession);
    620       f.close();
    621     }
    622   };
    623 }