app

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

received-envelopes.test.ts (8574B)


      1 import test from 'node:test';
      2 import assert from 'node:assert/strict';
      3 import {
      4   generateSecretKey,
      5   getPublicKey,
      6   getEventHash,
      7   finalizeEvent,
      8   type UnsignedEvent
      9 } from 'applesauce-core/helpers';
     10 import { nip44 } from 'applesauce-core/helpers/encryption';
     11 import { verifyReceivedLayerData } from '../../src/lib/nostr/unwrap-admission.ts';
     12 function fixture(extended = false) {
     13   const keys = [generateSecretKey(), generateSecretKey(), generateSecretKey()],
     14     sender = getPublicKey(keys[0]),
     15     owner = getPublicKey(keys[1]);
     16   const template: UnsignedEvent = {
     17     pubkey: sender,
     18     kind: 14,
     19     created_at: 1700000000,
     20     tags: extended
     21       ? [
     22           ['subject', 'Original subject'],
     23           ['q', 'b'.repeat(64), 'wss://untrusted.example.org', sender],
     24           ['vendor', 'inert metadata'],
     25           ['e', 'a'.repeat(64), 'wss://untrusted.example.org'],
     26           ['p', owner, 'wss://untrusted.example.org']
     27         ]
     28       : [['p', owner]],
     29     content: 'Bounded inbound enquiry'
     30   };
     31   const rumor = { id: getEventHash(template), ...template };
     32   const conversation = nip44.v2.utils.getConversationKey(keys[0], owner);
     33   let content: string;
     34   try {
     35     content = nip44.v2.encrypt(JSON.stringify(rumor), conversation);
     36   } finally {
     37     conversation.fill(0);
     38   }
     39   const seal = finalizeEvent(
     40     { kind: 13, created_at: 1699999900, tags: [], content },
     41     keys[0]
     42   );
     43   const wrapConversation = nip44.v2.utils.getConversationKey(keys[2], owner);
     44   let outerContent: string;
     45   try {
     46     outerContent = nip44.v2.encrypt(JSON.stringify(seal), wrapConversation);
     47   } finally {
     48     wrapConversation.fill(0);
     49   }
     50   const outer = finalizeEvent(
     51     {
     52       kind: 1059,
     53       created_at: 1699999800,
     54       tags: extended
     55         ? [
     56             ['nonce', '3', '8'],
     57             ['p', owner, 'wss://untrusted.example.org']
     58           ]
     59         : [['p', owner]],
     60       content: outerContent
     61     },
     62     keys[2]
     63   );
     64   const check = (r: unknown = rumor, s: unknown = seal, o: unknown = outer) =>
     65     verifyReceivedLayerData(
     66       JSON.stringify(o),
     67       JSON.stringify(s),
     68       JSON.stringify(r),
     69       owner
     70     );
     71   return {
     72     keys,
     73     sender,
     74     owner,
     75     rumor,
     76     seal,
     77     outer,
     78     check,
     79     close() {
     80       keys.forEach((k) => k.fill(0));
     81     }
     82   };
     83 }
     84 async function vector(
     85   name: string,
     86   run: (f: ReturnType<typeof fixture>) => void
     87 ) {
     88   await test(name, () => {
     89     const f = fixture();
     90     try {
     91       run(f);
     92     } finally {
     93       f.close();
     94     }
     95   });
     96 }
     97 await vector(
     98   'actual signed layers and freshly hashed unsigned pair rumor pass detached inspection',
     99   (f) => assert.equal(f.check(), true)
    100 );
    101 await test('fresh SDK nested extended wires retain original hashes and reject ambiguous/unsupported routing', () => {
    102   const f = fixture(true);
    103   try {
    104     assert.equal(f.check(), true);
    105     assert.equal(getEventHash(f.rumor), f.rumor.id);
    106     for (const extra of [
    107       ['p', f.owner],
    108       ['p', f.sender],
    109       ['subject', 'Another subject'],
    110       ['e', 'c'.repeat(64)],
    111       ['expiration', '1700000001'],
    112       ['file', 'https://untrusted.example.org'],
    113       ['imeta', 'url https://untrusted.example.org']
    114     ]) {
    115       const rumor = { ...f.rumor, tags: [...f.rumor.tags, extra] };
    116       rumor.id = getEventHash(rumor);
    117       assert.equal(f.check(rumor), false);
    118     }
    119     for (const tags of [
    120       [
    121         ['p', f.owner],
    122         ['p', f.owner]
    123       ],
    124       [
    125         ['p', f.owner],
    126         ['p', f.sender]
    127       ],
    128       [['p', f.sender, 'wss://untrusted.example.org']],
    129       [
    130         ['p', f.owner],
    131         ['expiration', '1700000001']
    132       ]
    133     ])
    134       assert.equal(
    135         f.check(
    136           f.rumor,
    137           f.seal,
    138           finalizeEvent({ ...f.outer, tags }, f.keys[2])
    139         ),
    140         false
    141       );
    142     assert.equal(
    143       f.check({ ...f.rumor, tags: [...f.rumor.tags].reverse() }),
    144       false
    145     );
    146     assert.equal(f.check(f.rumor, { ...f.seal, sig: '0'.repeat(128) }), false);
    147   } finally {
    148     f.close();
    149   }
    150 });
    151 await vector(
    152   'forged inner author fails even after recomputing rumor hash',
    153   (f) => {
    154     const r = { ...f.rumor, pubkey: f.owner };
    155     r.id = getEventHash(r);
    156     assert.equal(f.check(r), false);
    157   }
    158 );
    159 await vector('forged seal signature fails before nested rumor admission', (f) =>
    160   assert.equal(f.check(f.rumor, { ...f.seal, sig: '0'.repeat(128) }), false)
    161 );
    162 await vector(
    163   'a valid differently signed seal cannot authenticate original rumor author',
    164   (f) =>
    165     assert.equal(
    166       f.check(f.rumor, finalizeEvent({ ...f.seal }, f.keys[1])),
    167       false
    168     )
    169 );
    170 await vector('supplied rumor id is never a cache identity substitute', (f) =>
    171   assert.equal(f.check({ ...f.rumor, id: '0'.repeat(64) }), false)
    172 );
    173 await vector(
    174   'signed rumor is unsupported rather than silently accepted as unsigned14',
    175   (f) => assert.equal(f.check(finalizeEvent({ ...f.rumor }, f.keys[0])), false)
    176 );
    177 await vector('wrong kind and file metadata are isolated', (f) => {
    178   const r = {
    179     ...f.rumor,
    180     kind: 15,
    181     tags: [...f.rumor.tags, ['file', 'https://example.org/a']]
    182   };
    183   r.id = getEventHash(r);
    184   assert.equal(f.check(r), false);
    185 });
    186 await vector('group fanout cannot become an admitted pair rumor', (f) => {
    187   const r = {
    188     ...f.rumor,
    189     tags: [...f.rumor.tags, ['p', getPublicKey(f.keys[2])]]
    190   };
    191   r.id = getEventHash(r);
    192   assert.equal(f.check(r), false);
    193 });
    194 await vector('self-only participants are unsupported', (f) => {
    195   const r = { ...f.rumor, tags: [['p', f.sender]] };
    196   r.id = getEventHash(r);
    197   assert.equal(f.check(r), false);
    198 });
    199 await vector('nonempty seal tags are rejected despite a valid signature', (f) =>
    200   assert.equal(
    201     f.check(
    202       f.rumor,
    203       finalizeEvent({ ...f.seal, tags: [['client', 'unsupported']] }, f.keys[0])
    204     ),
    205     false
    206   )
    207 );
    208 await vector(
    209   'wrong outer destination cannot cross owner-scoped admission',
    210   (f) =>
    211     assert.equal(
    212       f.check(
    213         f.rumor,
    214         f.seal,
    215         finalizeEvent({ ...f.outer, tags: [['p', f.sender]] }, f.keys[2])
    216       ),
    217       false
    218     )
    219 );
    220 await vector(
    221   'signed original layers accept exact raw UTF8 byte limits and reject one-byte excess',
    222   (f) => {
    223     const wires = [
    224       JSON.stringify(f.outer),
    225       JSON.stringify(f.seal),
    226       JSON.stringify(f.rumor)
    227     ];
    228     const limits = [32768, 16384, 8192];
    229     for (let index = 0; index < wires.length; index++) {
    230       const boundary = [...wires];
    231       boundary[index] += ' '.repeat(
    232         limits[index] - Buffer.byteLength(boundary[index])
    233       );
    234       assert.equal(
    235         verifyReceivedLayerData(boundary[0], boundary[1], boundary[2], f.owner),
    236         true
    237       );
    238       boundary[index] += ' ';
    239       assert.equal(
    240         verifyReceivedLayerData(boundary[0], boundary[1], boundary[2], f.owner),
    241         false
    242       );
    243     }
    244   }
    245 );
    246 await vector('body and layer bounds are checked without truncation', (f) => {
    247   const r = { ...f.rumor, content: 'x'.repeat(4097) };
    248   r.id = getEventHash(r);
    249   assert.equal(f.check(r), false);
    250   assert.equal(
    251     verifyReceivedLayerData(
    252       JSON.stringify(f.outer),
    253       JSON.stringify(f.seal),
    254       'x'.repeat(8193),
    255       f.owner
    256     ),
    257     false
    258   );
    259 });
    260 await vector(
    261   'caller objects and imported or persisted verification markers cannot bypass fresh parsing',
    262   (f) => {
    263     let calls = 0;
    264     const value = {
    265       ...f.rumor,
    266       toJSON() {
    267         calls++;
    268         return f.rumor;
    269       }
    270     };
    271     assert.equal(
    272       verifyReceivedLayerData(
    273         JSON.stringify(f.outer),
    274         JSON.stringify(f.seal),
    275         value,
    276         f.owner
    277       ),
    278       false
    279     );
    280     assert.equal(calls, 0);
    281     assert.equal(f.check({ ...f.rumor, verified: true }), false);
    282   }
    283 );
    284 await vector(
    285   'harmless JSON whitespace works while duplicate fields and noncanonical numeric lexemes fail',
    286   (f) => {
    287     const o = JSON.stringify(f.outer),
    288       s = JSON.stringify(f.seal),
    289       r = JSON.stringify(f.rumor);
    290     assert.equal(
    291       verifyReceivedLayerData(
    292         ' ' + o + '\n',
    293         '\n' + s,
    294         JSON.stringify(f.rumor, null, 2),
    295         f.owner
    296       ),
    297       true
    298     );
    299     assert.equal(
    300       verifyReceivedLayerData(
    301         o,
    302         s,
    303         r.replace('"kind":14', '"kind":15,"kind":14'),
    304         f.owner
    305       ),
    306       false
    307     );
    308     assert.equal(
    309       verifyReceivedLayerData(o, s, r.replace('1700000000', '17e8'), f.owner),
    310       false
    311     );
    312     assert.deepEqual(
    313       [
    314         verifyReceivedLayerData(o, s, '{}', f.owner),
    315         verifyReceivedLayerData(o, s, r, f.owner)
    316       ],
    317       [false, true]
    318     );
    319   }
    320 );