nervur 0.12.0 → 0.13.0

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