@omnituum/pqc-shared 0.3.1 → 0.4.1

package/dist/crypto/safe/index.cjs

@@ -0,0 +1,556 @@
+'use strict';
+
+require('@noble/hashes/sha2.js');
+require('@noble/hashes/hmac.js');
+var mlKem_js = require('@noble/post-quantum/ml-kem.js');
+var nacl3 = require('tweetnacl');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var nacl3__default = /*#__PURE__*/_interopDefault(nacl3);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/crypto/safe/dilithium.ts
+var dilithium_exports = {};
+__export(dilithium_exports, {
+  keygen: () => keygen,
+  sign: () => sign,
+  verify: () => verify
+});
+
+// src/crypto/safe/manifests.ts
+var ML_DSA_65 = {
+  algorithm: "ML-DSA-65",
+  publicKeyBytes: 1952,
+  secretKeyBytes: 4032,
+  signatureBytes: 3309
+};
+var ML_KEM_768 = {
+  algorithm: "ML-KEM-768",
+  encapsulationKeyBytes: 1184,
+  decapsulationKeyBytes: 2400,
+  ciphertextBytes: 1088,
+  sharedSecretBytes: 32
+};
+var X25519 = {
+  algorithm: "X25519",
+  publicKeyBytes: 32,
+  secretKeyBytes: 32,
+  sharedSecretBytes: 32
+};
+var XSALSA20_POLY1305 = {
+  algorithm: "XSalsa20-Poly1305",
+  keyBytes: 32,
+  nonceBytes: 24,
+  tagBytes: 16
+};
+function assertSignaturePrimitive(noble, manifest) {
+  const msg = new Uint8Array([222, 173, 190, 239]);
+  const { publicKey, secretKey } = noble.keygen();
+  const sig = noble.sign(msg, secretKey);
+  if (publicKey.length !== manifest.publicKeyBytes) {
+    throw new Error(
+      `${manifest.algorithm}: publicKey ${publicKey.length} bytes, expected ${manifest.publicKeyBytes}`
+    );
+  }
+  if (secretKey.length !== manifest.secretKeyBytes) {
+    throw new Error(
+      `${manifest.algorithm}: secretKey ${secretKey.length} bytes, expected ${manifest.secretKeyBytes}`
+    );
+  }
+  if (sig.length !== manifest.signatureBytes) {
+    throw new Error(
+      `${manifest.algorithm}: signature ${sig.length} bytes, expected ${manifest.signatureBytes}`
+    );
+  }
+  if (!noble.verify(sig, msg, publicKey)) {
+    throw new Error(`${manifest.algorithm}: sign/verify roundtrip failed`);
+  }
+}
+function assertKemPrimitive(noble, manifest) {
+  const { publicKey, secretKey } = noble.keygen();
+  const { ciphertext, sharedSecret: ss1 } = noble.encapsulate(publicKey);
+  const ss2 = noble.decapsulate(ciphertext, secretKey);
+  if (publicKey.length !== manifest.encapsulationKeyBytes) {
+    throw new Error(
+      `${manifest.algorithm}: encapsulationKey ${publicKey.length} bytes, expected ${manifest.encapsulationKeyBytes}`
+    );
+  }
+  if (secretKey.length !== manifest.decapsulationKeyBytes) {
+    throw new Error(
+      `${manifest.algorithm}: decapsulationKey ${secretKey.length} bytes, expected ${manifest.decapsulationKeyBytes}`
+    );
+  }
+  if (ciphertext.length !== manifest.ciphertextBytes) {
+    throw new Error(
+      `${manifest.algorithm}: ciphertext ${ciphertext.length} bytes, expected ${manifest.ciphertextBytes}`
+    );
+  }
+  if (ss1.length !== manifest.sharedSecretBytes) {
+    throw new Error(
+      `${manifest.algorithm}: sharedSecret ${ss1.length} bytes, expected ${manifest.sharedSecretBytes}`
+    );
+  }
+  if (ss2.length !== manifest.sharedSecretBytes) {
+    throw new Error(
+      `${manifest.algorithm}: decapsulated sharedSecret ${ss2.length} bytes, expected ${manifest.sharedSecretBytes}`
+    );
+  }
+  for (let i = 0; i < ss1.length; i++) {
+    if (ss1[i] !== ss2[i]) {
+      throw new Error(`${manifest.algorithm}: encap/decap shared secrets differ at byte ${i}`);
+    }
+  }
+}
+function assertDhPrimitive(noble, manifest) {
+  const sk = noble.utils.randomPrivateKey();
+  const pk = noble.getPublicKey(sk);
+  if (pk.length !== manifest.publicKeyBytes) {
+    throw new Error(
+      `${manifest.algorithm}: publicKey ${pk.length} bytes, expected ${manifest.publicKeyBytes}`
+    );
+  }
+  if (sk.length !== manifest.secretKeyBytes) {
+    throw new Error(
+      `${manifest.algorithm}: secretKey ${sk.length} bytes, expected ${manifest.secretKeyBytes}`
+    );
+  }
+  const sk2 = noble.utils.randomPrivateKey();
+  const pk2 = noble.getPublicKey(sk2);
+  const ss1 = noble.getSharedSecret(sk, pk2);
+  const ss2 = noble.getSharedSecret(sk2, pk);
+  if (ss1.length !== manifest.sharedSecretBytes) {
+    throw new Error(
+      `${manifest.algorithm}: sharedSecret ${ss1.length} bytes, expected ${manifest.sharedSecretBytes}`
+    );
+  }
+  for (let i = 0; i < ss1.length; i++) {
+    if (ss1[i] !== ss2[i]) {
+      throw new Error(`${manifest.algorithm}: DH commutativity check failed at byte ${i}`);
+    }
+  }
+}
+
+// src/crypto/safe/dilithium.ts
+var _mod = null;
+var _invariantChecked = false;
+async function load() {
+  if (!_mod) {
+    const { ml_dsa65 } = await import('@noble/post-quantum/ml-dsa.js');
+    _mod = ml_dsa65;
+  }
+  return _mod;
+}
+async function checkInvariant() {
+  if (_invariantChecked) return;
+  const mod = await load();
+  assertSignaturePrimitive(mod, ML_DSA_65);
+  _invariantChecked = true;
+}
+async function keygen() {
+  const mod = await load();
+  await checkInvariant();
+  const kp = mod.keygen();
+  return {
+    publicKey: kp.publicKey,
+    secretKey: kp.secretKey
+  };
+}
+async function sign(params) {
+  const mod = await load();
+  await checkInvariant();
+  return mod.sign(params.message, params.secretKey);
+}
+async function verify(params) {
+  const mod = await load();
+  await checkInvariant();
+  try {
+    return mod.verify(params.signature, params.message, params.publicKey);
+  } catch {
+    return false;
+  }
+}
+
+// src/crypto/safe/kyber.ts
+var kyber_exports = {};
+__export(kyber_exports, {
+  decapsulate: () => decapsulate,
+  encapsulate: () => encapsulate,
+  keygen: () => keygen2
+});
+new TextEncoder();
+new TextDecoder();
+function toB64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function fromB64(str) {
+  const binary = atob(str);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function toHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function assertLen(label, arr, n) {
+  if (arr.length !== n) {
+    throw new Error(`${label} must be ${n} bytes, got ${arr.length}`);
+  }
+}
+function randN(n) {
+  return globalThis.crypto.getRandomValues(new Uint8Array(n));
+}
+var b64 = toB64;
+var ub64 = fromB64;
+async function generateKyberKeypair() {
+  const seed = randN(64);
+  const kp = mlKem_js.ml_kem1024.keygen(seed);
+  return {
+    publicB64: b64(kp.publicKey),
+    secretB64: b64(kp.secretKey)
+  };
+}
+async function kyberEncapsulate(pubKeyB64) {
+  const pk = ub64(pubKeyB64);
+  const enc = mlKem_js.ml_kem1024.encapsulate(pk);
+  return {
+    ciphertext: enc.cipherText,
+    sharedSecret: enc.sharedSecret
+  };
+}
+async function kyberDecapsulate(kemCiphertextB64, secretKeyB64) {
+  const ct = ub64(kemCiphertextB64);
+  const sk = ub64(secretKeyB64);
+  return mlKem_js.ml_kem1024.decapsulate(ct, sk);
+}
+
+// src/crypto/safe/kyber.ts
+async function keygen2() {
+  const kp = await generateKyberKeypair();
+  if (!kp) return null;
+  return {
+    encapsulationKey: fromB64(kp.publicB64),
+    decapsulationKey: fromB64(kp.secretB64)
+  };
+}
+async function encapsulate(params) {
+  const result = await kyberEncapsulate(toB64(params.encapsulationKey));
+  return {
+    ciphertext: result.ciphertext,
+    sharedSecret: result.sharedSecret
+  };
+}
+async function decapsulate(params) {
+  const ss = await kyberDecapsulate(toB64(params.ciphertext), toB64(params.decapsulationKey));
+  return ss;
+}
+
+// src/crypto/safe/x25519.ts
+var x25519_exports = {};
+__export(x25519_exports, {
+  keygen: () => keygen3,
+  sharedSecret: () => sharedSecret
+});
+function generateX25519Keypair() {
+  const kp = nacl3__default.default.box.keyPair();
+  return {
+    publicHex: "0x" + toHex(kp.publicKey),
+    secretHex: "0x" + toHex(kp.secretKey),
+    publicBytes: kp.publicKey,
+    secretBytes: kp.secretKey
+  };
+}
+function x25519SharedSecret(ourSecretKey, theirPublicKey) {
+  assertLen("secret key", ourSecretKey, 32);
+  assertLen("public key", theirPublicKey, 32);
+  return nacl3__default.default.scalarMult(ourSecretKey, theirPublicKey);
+}
+
+// src/crypto/safe/x25519.ts
+function keygen3() {
+  const kp = generateX25519Keypair();
+  return {
+    publicKey: kp.publicBytes,
+    secretKey: kp.secretBytes
+  };
+}
+function sharedSecret(params) {
+  return x25519SharedSecret(params.ourSecretKey, params.theirPublicKey);
+}
+
+// src/crypto/safe/secretbox.ts
+var secretbox_exports = {};
+__export(secretbox_exports, {
+  open: () => open,
+  seal: () => seal
+});
+function secretboxRaw(key, plaintext, nonce) {
+  assertLen("secretbox key", key, 32);
+  assertLen("nonce", nonce, 24);
+  return nacl3__default.default.secretbox(plaintext, nonce, key);
+}
+function secretboxOpenRaw(key, ciphertext, nonce) {
+  assertLen("secretbox key", key, 32);
+  assertLen("nonce", nonce, 24);
+  return nacl3__default.default.secretbox.open(ciphertext, nonce, key) || null;
+}
+nacl3__default.default.secretbox.keyLength;
+nacl3__default.default.secretbox.nonceLength;
+nacl3__default.default.secretbox.overheadLength;
+nacl3__default.default.box.publicKeyLength;
+nacl3__default.default.box.nonceLength;
+
+// src/crypto/safe/secretbox.ts
+function seal(params) {
+  return secretboxRaw(params.key, params.plaintext, params.nonce);
+}
+function open(params) {
+  return secretboxOpenRaw(params.key, params.ciphertext, params.nonce);
+}
+
+// src/crypto/safe/types.ts
+function asMessage(data) {
+  return data;
+}
+function asDilithiumSecretKey(data) {
+  return data;
+}
+function asDilithiumPublicKey(data) {
+  return data;
+}
+function asKyberEncapsulationKey(data) {
+  return data;
+}
+function asKyberDecapsulationKey(data) {
+  return data;
+}
+function asX25519PublicKey(data) {
+  return data;
+}
+function asX25519SecretKey(data) {
+  return data;
+}
+function asSymmetricKey(data) {
+  return data;
+}
+function asNonce(data) {
+  return data;
+}
+
+// src/crypto/safe/adapters.ts
+function makeSignatureAdapter(noble, manifest) {
+  let checked = false;
+  const alg = manifest.algorithm;
+  function ensureInvariant() {
+    if (checked) return;
+    const msg = new Uint8Array([222, 173, 190, 239]);
+    const { publicKey, secretKey } = noble.keygen();
+    const sig = noble.sign(msg, secretKey);
+    if (publicKey.length !== manifest.publicKeyBytes) {
+      throw new Error(`${alg}: publicKey ${publicKey.length}B, expected ${manifest.publicKeyBytes}B`);
+    }
+    if (secretKey.length !== manifest.secretKeyBytes) {
+      throw new Error(`${alg}: secretKey ${secretKey.length}B, expected ${manifest.secretKeyBytes}B`);
+    }
+    if (sig.length !== manifest.signatureBytes) {
+      throw new Error(`${alg}: signature ${sig.length}B, expected ${manifest.signatureBytes}B`);
+    }
+    if (!noble.verify(sig, msg, publicKey)) {
+      throw new Error(`${alg}: sign/verify roundtrip failed`);
+    }
+    checked = true;
+  }
+  return {
+    keygen() {
+      ensureInvariant();
+      const kp = noble.keygen();
+      return {
+        publicKey: kp.publicKey,
+        secretKey: kp.secretKey
+      };
+    },
+    sign(params) {
+      ensureInvariant();
+      return noble.sign(params.message, params.secretKey);
+    },
+    verify(params) {
+      ensureInvariant();
+      return noble.verify(params.signature, params.message, params.publicKey);
+    }
+  };
+}
+function asSigMessage(v) {
+  return v;
+}
+function makeKemAdapter(noble, manifest) {
+  let checked = false;
+  const alg = manifest.algorithm;
+  function ensureInvariant() {
+    if (checked) return;
+    const { publicKey, secretKey } = noble.keygen();
+    const { ciphertext, sharedSecret: ss1 } = noble.encapsulate(publicKey);
+    const ss2 = noble.decapsulate(ciphertext, secretKey);
+    if (publicKey.length !== manifest.encapsulationKeyBytes) {
+      throw new Error(`${alg}: encapsKey ${publicKey.length}B, expected ${manifest.encapsulationKeyBytes}B`);
+    }
+    if (secretKey.length !== manifest.decapsulationKeyBytes) {
+      throw new Error(`${alg}: decapsKey ${secretKey.length}B, expected ${manifest.decapsulationKeyBytes}B`);
+    }
+    if (ciphertext.length !== manifest.ciphertextBytes) {
+      throw new Error(`${alg}: ciphertext ${ciphertext.length}B, expected ${manifest.ciphertextBytes}B`);
+    }
+    if (ss1.length !== manifest.sharedSecretBytes) {
+      throw new Error(`${alg}: sharedSecret ${ss1.length}B, expected ${manifest.sharedSecretBytes}B`);
+    }
+    if (ss2.length !== ss1.length) {
+      throw new Error(`${alg}: encap/decap shared secret length mismatch`);
+    }
+    for (let i = 0; i < ss1.length; i++) {
+      if (ss1[i] !== ss2[i]) throw new Error(`${alg}: encap/decap shared secrets differ`);
+    }
+    checked = true;
+  }
+  return {
+    keygen() {
+      ensureInvariant();
+      const kp = noble.keygen();
+      return {
+        encapsulationKey: kp.publicKey,
+        decapsulationKey: kp.secretKey
+      };
+    },
+    encapsulate(params) {
+      ensureInvariant();
+      const result = noble.encapsulate(params.encapsulationKey);
+      return {
+        ciphertext: result.ciphertext,
+        sharedSecret: result.sharedSecret
+      };
+    },
+    decapsulate(params) {
+      ensureInvariant();
+      return noble.decapsulate(params.ciphertext, params.decapsulationKey);
+    }
+  };
+}
+function makeDhAdapter(noble, manifest) {
+  let checked = false;
+  const alg = manifest.algorithm;
+  function ensureInvariant() {
+    if (checked) return;
+    const sk = noble.utils.randomPrivateKey();
+    const pk = noble.getPublicKey(sk);
+    if (pk.length !== manifest.publicKeyBytes) {
+      throw new Error(`${alg}: publicKey ${pk.length}B, expected ${manifest.publicKeyBytes}B`);
+    }
+    if (sk.length !== manifest.secretKeyBytes) {
+      throw new Error(`${alg}: secretKey ${sk.length}B, expected ${manifest.secretKeyBytes}B`);
+    }
+    const sk2 = noble.utils.randomPrivateKey();
+    const pk2 = noble.getPublicKey(sk2);
+    const ss1 = noble.getSharedSecret(sk, pk2);
+    const ss2 = noble.getSharedSecret(sk2, pk);
+    if (ss1.length !== manifest.sharedSecretBytes) {
+      throw new Error(`${alg}: sharedSecret ${ss1.length}B, expected ${manifest.sharedSecretBytes}B`);
+    }
+    for (let i = 0; i < ss1.length; i++) {
+      if (ss1[i] !== ss2[i]) throw new Error(`${alg}: DH commutativity failed`);
+    }
+    checked = true;
+  }
+  return {
+    keygen() {
+      ensureInvariant();
+      const secretKey = noble.utils.randomPrivateKey();
+      const publicKey = noble.getPublicKey(secretKey);
+      return {
+        publicKey,
+        secretKey
+      };
+    },
+    sharedSecret(params) {
+      ensureInvariant();
+      return noble.getSharedSecret(params.ourSecretKey, params.theirPublicKey);
+    }
+  };
+}
+function makeSecretboxAdapter(impl, manifest) {
+  let checked = false;
+  const alg = manifest.algorithm;
+  function ensureInvariant() {
+    if (checked) return;
+    const key = new Uint8Array(manifest.keyBytes);
+    crypto.getRandomValues(key);
+    const nonce = new Uint8Array(manifest.nonceBytes);
+    crypto.getRandomValues(nonce);
+    const plaintext = new Uint8Array([202, 254, 186, 190]);
+    const ct = impl.seal(key, plaintext, nonce);
+    const overhead = ct.length - plaintext.length;
+    if (overhead !== manifest.tagBytes) {
+      throw new Error(`${alg}: overhead ${overhead}B, expected ${manifest.tagBytes}B tag`);
+    }
+    const pt = impl.open(key, ct, nonce);
+    if (!pt || pt.length !== plaintext.length) {
+      throw new Error(`${alg}: seal/open roundtrip failed`);
+    }
+    for (let i = 0; i < plaintext.length; i++) {
+      if (pt[i] !== plaintext[i]) throw new Error(`${alg}: seal/open roundtrip mismatch`);
+    }
+    checked = true;
+  }
+  return {
+    seal(params) {
+      ensureInvariant();
+      return impl.seal(params.key, params.plaintext, params.nonce);
+    },
+    open(params) {
+      ensureInvariant();
+      return impl.open(params.key, params.ciphertext, params.nonce);
+    }
+  };
+}
+function asBoxKey(v) {
+  return v;
+}
+function asBoxNonce(v) {
+  return v;
+}
+
+exports.ML_DSA_65 = ML_DSA_65;
+exports.ML_KEM_768 = ML_KEM_768;
+exports.X25519 = X25519;
+exports.XSALSA20_POLY1305 = XSALSA20_POLY1305;
+exports.asBoxKey = asBoxKey;
+exports.asBoxNonce = asBoxNonce;
+exports.asDilithiumPublicKey = asDilithiumPublicKey;
+exports.asDilithiumSecretKey = asDilithiumSecretKey;
+exports.asKyberDecapsulationKey = asKyberDecapsulationKey;
+exports.asKyberEncapsulationKey = asKyberEncapsulationKey;
+exports.asMessage = asMessage;
+exports.asNonce = asNonce;
+exports.asSigMessage = asSigMessage;
+exports.asSymmetricKey = asSymmetricKey;
+exports.asX25519PublicKey = asX25519PublicKey;
+exports.asX25519SecretKey = asX25519SecretKey;
+exports.assertDhPrimitive = assertDhPrimitive;
+exports.assertKemPrimitive = assertKemPrimitive;
+exports.assertSignaturePrimitive = assertSignaturePrimitive;
+exports.dilithium = dilithium_exports;
+exports.kyber = kyber_exports;
+exports.makeDhAdapter = makeDhAdapter;
+exports.makeKemAdapter = makeKemAdapter;
+exports.makeSecretboxAdapter = makeSecretboxAdapter;
+exports.makeSignatureAdapter = makeSignatureAdapter;
+exports.secretbox = secretbox_exports;
+exports.x25519 = x25519_exports;