@omnituum/pqc-shared 0.3.1 → 0.4.1

package/dist/crypto/safe/index.js

@@ -0,0 +1,524 @@
+import '@noble/hashes/sha2.js';
+import '@noble/hashes/hmac.js';
+import { ml_kem1024 } from '@noble/post-quantum/ml-kem.js';
+import nacl3 from 'tweetnacl';
+
+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 = ml_kem1024.keygen(seed);
+  return {
+    publicB64: b64(kp.publicKey),
+    secretB64: b64(kp.secretKey)
+  };
+}
+async function kyberEncapsulate(pubKeyB64) {
+  const pk = ub64(pubKeyB64);
+  const enc = 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 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.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.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.secretbox(plaintext, nonce, key);
+}
+function secretboxOpenRaw(key, ciphertext, nonce) {
+  assertLen("secretbox key", key, 32);
+  assertLen("nonce", nonce, 24);
+  return nacl3.secretbox.open(ciphertext, nonce, key) || null;
+}
+nacl3.secretbox.keyLength;
+nacl3.secretbox.nonceLength;
+nacl3.secretbox.overheadLength;
+nacl3.box.publicKeyLength;
+nacl3.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;
+}
+
+export { ML_DSA_65, ML_KEM_768, X25519, XSALSA20_POLY1305, asBoxKey, asBoxNonce, asDilithiumPublicKey, asDilithiumSecretKey, asKyberDecapsulationKey, asKyberEncapsulationKey, asMessage, asNonce, asSigMessage, asSymmetricKey, asX25519PublicKey, asX25519SecretKey, assertDhPrimitive, assertKemPrimitive, assertSignaturePrimitive, dilithium_exports as dilithium, kyber_exports as kyber, makeDhAdapter, makeKemAdapter, makeSecretboxAdapter, makeSignatureAdapter, secretbox_exports as secretbox, x25519_exports as x25519 };

package/dist/fs/index.cjs

@@ -4,6 +4,7 @@ var hashWasm = require('hash-wasm');
 var sha2_js = require('@noble/hashes/sha2.js');
 var hmac_js = require('@noble/hashes/hmac.js');
 var nacl2 = require('tweetnacl');
+var mlKem_js = require('@noble/post-quantum/ml-kem.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -548,50 +549,21 @@ function getAlgorithmName(suiteId) {
   }
   return `Unknown (0x${suiteId.toString(16)})`;
 }
-var kyberModule = null;
-async function loadKyber() {
-  if (kyberModule) return kyberModule;
-  try {
-    const m = await import('kyber-crystals');
-    const k = m.default ?? m;
-    kyberModule = k.kyber ?? k;
-    return kyberModule;
-  } catch (e) {
-    console.warn("[Kyber] Failed to load kyber-crystals:", e);
-    return null;
-  }
-}
 async function isKyberAvailable() {
-  const mod = await loadKyber();
-  return mod !== null;
+  return true;
 }
 async function kyberEncapsulate(pubKeyB64) {
-  const kyber = await loadKyber();
-  if (!kyber?.encrypt) {
-    throw new Error("Kyber encrypt not available");
-  }
   const pk = ub64(pubKeyB64);
-  const r = await kyber.encrypt(pk);
-  const ctRaw = r?.ciphertext ?? r?.cyphertext ?? r?.ct ?? r?.bytes?.ciphertext ?? r?.bytes?.cyphertext ?? r?.bytes?.ct ?? (Array.isArray(r) ? r[0] : void 0);
-  const ssRaw = r?.key ?? r?.sharedSecret ?? r?.secret ?? r?.bytes?.key ?? r?.bytes?.sharedSecret ?? (Array.isArray(r) ? r[1] : void 0);
-  if (!ctRaw || !ssRaw) {
-    throw new Error("Kyber encapsulate failed: missing ciphertext or shared secret");
-  }
+  const enc = mlKem_js.ml_kem1024.encapsulate(pk);
   return {
-    ciphertext: new Uint8Array(ctRaw),
-    sharedSecret: new Uint8Array(ssRaw)
+    ciphertext: enc.cipherText,
+    sharedSecret: enc.sharedSecret
   };
 }
 async function kyberDecapsulate(kemCiphertextB64, secretKeyB64) {
-  const kyber = await loadKyber();
-  if (!kyber?.decrypt && !kyber?.decapsulate) {
-    throw new Error("Kyber decrypt/decapsulate not available");
-  }
   const ct = ub64(kemCiphertextB64);
   const sk = ub64(secretKeyB64);
-  const r = kyber.decrypt ? await kyber.decrypt(ct, sk) : await kyber.decapsulate(ct, sk);
-  const key = r && (r.key ?? r.sharedSecret) ? r.key ?? r.sharedSecret : r;
-  return new Uint8Array(key);
+  return mlKem_js.ml_kem1024.decapsulate(ct, sk);
 }
 
 // src/fs/encrypt.ts

package/dist/fs/index.js

@@ -2,6 +2,7 @@ import { argon2id } from 'hash-wasm';
 import { sha256 as sha256$1 } from '@noble/hashes/sha2.js';
 import { hmac } from '@noble/hashes/hmac.js';
 import nacl2 from 'tweetnacl';
+import { ml_kem1024 } from '@noble/post-quantum/ml-kem.js';
 
 // src/fs/types.ts
 var OQE_MAGIC = new Uint8Array([79, 81, 69, 70]);
@@ -542,50 +543,21 @@ function getAlgorithmName(suiteId) {
   }
   return `Unknown (0x${suiteId.toString(16)})`;
 }
-var kyberModule = null;
-async function loadKyber() {
-  if (kyberModule) return kyberModule;
-  try {
-    const m = await import('kyber-crystals');
-    const k = m.default ?? m;
-    kyberModule = k.kyber ?? k;
-    return kyberModule;
-  } catch (e) {
-    console.warn("[Kyber] Failed to load kyber-crystals:", e);
-    return null;
-  }
-}
 async function isKyberAvailable() {
-  const mod = await loadKyber();
-  return mod !== null;
+  return true;
 }
 async function kyberEncapsulate(pubKeyB64) {
-  const kyber = await loadKyber();
-  if (!kyber?.encrypt) {
-    throw new Error("Kyber encrypt not available");
-  }
   const pk = ub64(pubKeyB64);
-  const r = await kyber.encrypt(pk);
-  const ctRaw = r?.ciphertext ?? r?.cyphertext ?? r?.ct ?? r?.bytes?.ciphertext ?? r?.bytes?.cyphertext ?? r?.bytes?.ct ?? (Array.isArray(r) ? r[0] : void 0);
-  const ssRaw = r?.key ?? r?.sharedSecret ?? r?.secret ?? r?.bytes?.key ?? r?.bytes?.sharedSecret ?? (Array.isArray(r) ? r[1] : void 0);
-  if (!ctRaw || !ssRaw) {
-    throw new Error("Kyber encapsulate failed: missing ciphertext or shared secret");
-  }
+  const enc = ml_kem1024.encapsulate(pk);
   return {
-    ciphertext: new Uint8Array(ctRaw),
-    sharedSecret: new Uint8Array(ssRaw)
+    ciphertext: enc.cipherText,
+    sharedSecret: enc.sharedSecret
   };
 }
 async function kyberDecapsulate(kemCiphertextB64, secretKeyB64) {
-  const kyber = await loadKyber();
-  if (!kyber?.decrypt && !kyber?.decapsulate) {
-    throw new Error("Kyber decrypt/decapsulate not available");
-  }
   const ct = ub64(kemCiphertextB64);
   const sk = ub64(secretKeyB64);
-  const r = kyber.decrypt ? await kyber.decrypt(ct, sk) : await kyber.decapsulate(ct, sk);
-  const key = r && (r.key ?? r.sharedSecret) ? r.key ?? r.sharedSecret : r;
-  return new Uint8Array(key);
+  return ml_kem1024.decapsulate(ct, sk);
 }
 
 // src/fs/encrypt.ts