nervur 0.12.0 → 0.14.0

package/tools.mjs

@@ -1,13 +1,57 @@
-import {
-  createCipheriv,
-  createDecipheriv,
-  createHash,
-  createPublicKey,
-  randomBytes,
-  verify,
-} from 'node:crypto';
+import { ed25519 } from '@noble/curves/ed25519.js';
+import { sha256 } from '@noble/hashes/sha2.js';
 
-const ED25519_SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex');
+const HEX = '0123456789abcdef';
+
+const utf8 = new TextEncoder();
+const text8 = new TextDecoder();
+
+// Buffer is Node's alone. Every byte string here is a Uint8Array, and these
+// are the encodings the substrate names: hex on a digest, base64 on a
+// signature, utf8 under canon.
+const Bytes = Object.freeze({
+  base64: (bytes) => {
+    let binary = '';
+    for (const byte of bytes) {
+      binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+  },
+  concat: (parts) => {
+    const whole = new Uint8Array(parts.reduce((run, one) => run + one.length, 0));
+    let at = 0;
+    for (const one of parts) {
+      whole.set(one, at);
+      at += one.length;
+    }
+    return whole;
+  },
+  equal: (one, other) => one.length === other.length && one.every((byte, at) => byte === other[at]),
+  hex: (bytes) => {
+    let out = '';
+    for (const byte of bytes) {
+      out += HEX[byte >> 4] + HEX[byte & 15];
+    }
+    return out;
+  },
+  of: (value) => utf8.encode(value),
+  read: (bytes) => text8.decode(bytes),
+  unbase64: (value) => {
+    const binary = atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for (let at = 0; at < binary.length; at += 1) {
+      bytes[at] = binary.charCodeAt(at);
+    }
+    return bytes;
+  },
+  unhex: (value) => {
+    const bytes = new Uint8Array(value.length >> 1);
+    for (let at = 0; at < bytes.length; at += 1) {
+      bytes[at] = Number.parseInt(value.substr(at << 1, 2), 16);
+    }
+    return bytes;
+  },
+});
 
 const B32 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
 
@@ -70,21 +114,23 @@ const unbase32 = (text) => {
       bits -= 8;
     }
   }
-  return Buffer.from(out);
+  return Uint8Array.from(out);
 };
 
 const Tools = Object.freeze({
   address: (pk) => {
-    const payload = Buffer.concat([Buffer.from([VERSION_G]), pk]);
+    const payload = Bytes.concat([Uint8Array.of(VERSION_G), pk]);
     const crc = crc16(payload);
-    return base32(Buffer.concat([payload, Buffer.from([crc & 0xff, crc >> 8])]));
+    return base32(Bytes.concat([payload, Uint8Array.of(crc & 0xff, crc >> 8)]));
   },
-  canon: (claim) => Buffer.from(JSON.stringify(ordered(claim))),
-  derive: (root, label) => createHash('sha256').update(root).update(label).digest(),
-  digest: (bytes) => createHash('sha256').update(bytes).digest('hex'),
-  envelope: (voice, to, op, seq) => {
+  canon: (claim) => Bytes.of(JSON.stringify(ordered(claim))),
+  // The label arrives as text and the digest is over its utf8 bytes, which is
+  // the byte string the substrate has always hashed.
+  derive: (root, label) => sha256.create().update(root).update(Bytes.of(label)).digest(),
+  digest: (bytes) => Bytes.hex(sha256(bytes)),
+  envelope: async (voice, to, op, seq) => {
     const from = Tools.address(voice.pk);
-    return { from, op, seq, sig: voice.sign(Tools.canon({ from, op, seq, to })), to };
+    return { from, op, seq, sig: await voice.sign(Tools.canon({ from, op, seq, to })), to };
   },
   pkOf: (address) => {
     const bytes = typeof address === 'string' && address.length === 56 ? unbase32(address) : null;
@@ -93,39 +139,12 @@ const Tools = Object.freeze({
     }
     const payload = bytes.subarray(0, 33);
     const checksum = bytes[33] | (bytes[34] << 8);
-    return crc16(payload) === checksum ? Buffer.from(payload.subarray(1)) : null;
-  },
-  seal: (secret, value) => {
-    const iv = randomBytes(12);
-    const cipher = createCipheriv('aes-256-gcm', secret, iv);
-    const sealed = Buffer.concat([cipher.update(JSON.stringify(value), 'utf8'), cipher.final()]);
-    return Buffer.concat([iv, cipher.getAuthTag(), sealed]).toString('base64');
-  },
-  secret: () => randomBytes(32),
-  unseal: (secret, sealed) => {
-    try {
-      const bytes = Buffer.from(sealed, 'base64');
-      const decipher = createDecipheriv('aes-256-gcm', secret, bytes.subarray(0, 12));
-      decipher.setAuthTag(bytes.subarray(12, 28));
-      return JSON.parse(
-        Buffer.concat([decipher.update(bytes.subarray(28)), decipher.final()]).toString('utf8'),
-      );
-    } catch {
-      return undefined;
-    }
+    return crc16(payload) === checksum ? payload.slice(1) : null;
   },
+  secret: () => crypto.getRandomValues(new Uint8Array(32)),
   verifies: (pk, bytes, sig) => {
     try {
-      return verify(
-        null,
-        bytes,
-        createPublicKey({
-          key: Buffer.concat([ED25519_SPKI_PREFIX, pk]),
-          format: 'der',
-          type: 'spki',
-        }),
-        Buffer.from(sig, 'base64'),
-      );
+      return ed25519.verify(Bytes.unbase64(sig), bytes, pk);
     } catch {
       return false;
     }
@@ -140,4 +159,4 @@ const Stamp = () => {
   };
 };
 
-export { MEASURE, SPAN, Stamp, Tools };
+export { Bytes, MEASURE, SPAN, Stamp, Tools };

package/voice.mjs

@@ -1,69 +1,63 @@
-import {
-  createHash,
-  createPrivateKey,
-  createPublicKey,
-  diffieHellman,
-  generateKeyPairSync,
-  sign,
-} from 'node:crypto';
-import { Tools } from './tools.mjs';
+import { ed25519, x25519 } from '@noble/curves/ed25519.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { Bytes, Tools } from './tools.mjs';
 
-const X25519_SPKI_PREFIX = Buffer.from('302a300506032b656e032100', 'hex');
+// A private key travels as PKCS8 DER in base64 — the shape every stored
+// bundle and every hand on the wire already carries — and a PKCS8 Ed25519 or
+// X25519 key is one fixed prefix and the thirty-two seed bytes, so the bytes
+// are the same whoever assembles them.
+const ED_PKCS8 = Bytes.unhex('302e020100300506032b657004220420');
+const X_PKCS8 = Bytes.unhex('302e020100300506032b656e04220420');
 
-const packed = (privateKey) =>
-  privateKey.export({ format: 'der', type: 'pkcs8' }).toString('base64');
+const seeded = () => crypto.getRandomValues(new Uint8Array(32));
 
-const unpacked = (text) =>
-  createPrivateKey({ key: Buffer.from(text, 'base64'), format: 'der', type: 'pkcs8' });
+const packed = (raw, prefix) => Bytes.base64(Bytes.concat([prefix, raw]));
 
-const rawPk = (privateKey) =>
-  createPublicKey(privateKey).export({ format: 'der', type: 'spki' }).subarray(-32);
+const unpacked = (text, prefix) => {
+  const der = Bytes.unbase64(text);
+  if (der.length !== prefix.length + 32 || !Bytes.equal(der.subarray(0, prefix.length), prefix)) {
+    throw new Error('not a key of this curve');
+  }
+  return der.subarray(prefix.length);
+};
 
-const agreed = (privateKey, rawPub) =>
-  createHash('sha256')
-    .update(
-      diffieHellman({
-        privateKey,
-        publicKey: createPublicKey({
-          key: Buffer.concat([X25519_SPKI_PREFIX, rawPub]),
-          format: 'der',
-          type: 'spki',
-        }),
-      }),
-    )
-    .digest();
+const agreed = (box, rawPub) => sha256(x25519.getSharedSecret(box, rawPub));
 
 const committed = /^[0-9a-f]{64}$/;
 
 const voiced = ({ present, next, box, nextPkHash }) =>
   Object.freeze({
-    boxPk: rawPk(box),
-    nextPkHash: next === undefined ? nextPkHash : Tools.digest(rawPk(next)),
-    open: (wrapped) => {
+    boxPk: x25519.getPublicKey(box),
+    nextPkHash: next === undefined ? nextPkHash : Tools.digest(ed25519.getPublicKey(next)),
+    open: (wrapped, cipher) => {
       try {
         const [ephemeral, sealed] = wrapped.split('.');
-        return Tools.unseal(agreed(box, Buffer.from(ephemeral, 'base64')), sealed);
+        return cipher.unseal(agreed(box, Bytes.unbase64(ephemeral)), sealed);
       } catch {
         return undefined;
       }
     },
     hand: () => ({
-      box: packed(box),
-      nextPkHash: next === undefined ? nextPkHash : Tools.digest(rawPk(next)),
-      present: packed(present),
+      box: packed(box, X_PKCS8),
+      nextPkHash: next === undefined ? nextPkHash : Tools.digest(ed25519.getPublicKey(next)),
+      present: packed(present, ED_PKCS8),
     }),
     pack: () =>
       next === undefined
-        ? { box: packed(box), nextPkHash, present: packed(present) }
-        : { box: packed(box), next: packed(next), present: packed(present) },
-    pk: rawPk(present),
-    sign: (bytes) => sign(null, bytes, present).toString('base64'),
+        ? { box: packed(box, X_PKCS8), nextPkHash, present: packed(present, ED_PKCS8) }
+        : {
+            box: packed(box, X_PKCS8),
+            next: packed(next, ED_PKCS8),
+            present: packed(present, ED_PKCS8),
+          },
+    pk: ed25519.getPublicKey(present),
+    sign: (bytes) => Bytes.base64(ed25519.sign(bytes, present)),
     succeed: () =>
       next === undefined
         ? undefined
         : voiced({
-            box: generateKeyPairSync('x25519').privateKey,
-            next: generateKeyPairSync('ed25519').privateKey,
+            box: seeded(),
+            next: seeded(),
             present: next,
           }),
   });
@@ -72,18 +66,10 @@ const Voice = Object.freeze(
   Object.assign(
     (nextPkHash) => {
       if (nextPkHash === undefined) {
-        return voiced({
-          box: generateKeyPairSync('x25519').privateKey,
-          next: generateKeyPairSync('ed25519').privateKey,
-          present: generateKeyPairSync('ed25519').privateKey,
-        });
+        return voiced({ box: seeded(), next: seeded(), present: seeded() });
       }
       return committed.test(nextPkHash)
-        ? voiced({
-            box: generateKeyPairSync('x25519').privateKey,
-            nextPkHash,
-            present: generateKeyPairSync('ed25519').privateKey,
-          })
+        ? voiced({ box: seeded(), nextPkHash, present: seeded() })
         : undefined;
     },
     {
@@ -92,27 +78,27 @@ const Voice = Object.freeze(
           if (bundle.next === undefined) {
             return committed.test(bundle.nextPkHash)
               ? voiced({
-                  box: unpacked(bundle.box),
+                  box: unpacked(bundle.box, X_PKCS8),
                   nextPkHash: bundle.nextPkHash,
-                  present: unpacked(bundle.present),
+                  present: unpacked(bundle.present, ED_PKCS8),
                 })
               : undefined;
           }
           return voiced({
-            box: unpacked(bundle.box),
-            next: unpacked(bundle.next),
-            present: unpacked(bundle.present),
+            box: unpacked(bundle.box, X_PKCS8),
+            next: unpacked(bundle.next, ED_PKCS8),
+            present: unpacked(bundle.present, ED_PKCS8),
           });
         } catch {
           return undefined;
         }
       },
-      sealTo: (boxPk, value) => {
-        const ephemeral = generateKeyPairSync('x25519');
-        return `${rawPk(ephemeral.privateKey).toString('base64')}.${Tools.seal(
-          agreed(ephemeral.privateKey, boxPk),
-          value,
-        )}`;
+      sealTo: (boxPk, value, cipher) => {
+        const ephemeral = seeded();
+        const shut = cipher?.seal(agreed(ephemeral, boxPk), value);
+        return shut === undefined
+          ? undefined
+          : `${Bytes.base64(x25519.getPublicKey(ephemeral))}.${shut}`;
       },
     },
   ),