@omnituum/pqc-shared 0.3.0 → 0.4.0

package/dist/vault/index.d.ts

@@ -1,6 +1,5 @@
-import { O as OmnituumVault, E as EncryptedVaultFile, a as EncryptedVaultFileV2, H as HybridIdentityRecord, V as VaultSettings, b as VaultSession } from '../types-61c7Q9ri.js';
-export { D as DEFAULT_VAULT_SETTINGS, c as EncryptedVaultFileV1, d as HealthStatus, I as IdentityHealth, P as PBKDF2_ITERATIONS } from '../types-61c7Q9ri.js';
-import '../version-BygzPVGs.js';
+import { O as OmnituumVault, E as EncryptedVaultFile, k as EncryptedVaultFileV2, H as HybridIdentityRecord, l as VaultSettings, m as VaultSession } from '../types-Dx_AFqow.js';
+export { D as DEFAULT_VAULT_SETTINGS, n as EncryptedVaultFileV1, o as HealthStatus, I as IdentityHealth, P as PBKDF2_ITERATIONS } from '../types-Dx_AFqow.js';
 
 /**
  * Omnituum PQC Shared - Vault Encryption

package/dist/vault/index.js

@@ -1,7 +1,9 @@
 import '@noble/hashes/sha2.js';
 import '@noble/hashes/hmac.js';
+import { OMNI_VERSIONS, DEPRECATED_VERSIONS } from '@omnituum/envelope-registry';
 import { argon2id } from 'hash-wasm';
 import nacl from 'tweetnacl';
+import { ml_kem1024 } from '@noble/post-quantum/ml-kem.js';
 import '@noble/hashes/blake3.js';
 import '@noble/ciphers/chacha.js';
 import '@noble/hashes/hkdf.js';
@@ -33,9 +35,12 @@ function fromB64(str) {
 function toHex(bytes) {
   return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
+function randN(n) {
+  return globalThis.crypto.getRandomValues(new Uint8Array(n));
+}
 var b64 = toB64;
-
-// src/version.ts
+OMNI_VERSIONS.HYBRID_V1;
+DEPRECATED_VERSIONS.PQC_DEMO_HYBRID_V1;
 var VAULT_VERSION = "omnituum.vault.v1";
 var VAULT_ENCRYPTED_VERSION = "omnituum.vault.enc.v1";
 var VAULT_ENCRYPTED_VERSION_V2 = "omnituum.vault.enc.v2";
@@ -358,46 +363,13 @@ function generateX25519Keypair() {
     secretBytes: kp.secretKey
   };
 }
-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 generateKyberKeypair() {
-  try {
-    const mod = await loadKyber();
-    if (!mod) return null;
-    if (mod?.ready?.then) {
-      await mod.ready;
-    }
-    const fn = mod?.keypair ?? mod?.keyPair ?? mod?.generateKeyPair ?? null;
-    if (typeof fn !== "function") {
-      console.warn("[Kyber] No keypair function found");
-      return null;
-    }
-    const kp = await fn.call(mod);
-    const pub = kp?.publicKey ?? kp?.public ?? kp?.pk;
-    const priv = kp?.privateKey ?? kp?.secretKey ?? kp?.secret ?? kp?.sk;
-    if (!pub || !priv) {
-      console.warn("[Kyber] Invalid keypair result");
-      return null;
-    }
-    return {
-      publicB64: b64(new Uint8Array(pub)),
-      secretB64: b64(new Uint8Array(priv))
-    };
-  } catch (e) {
-    console.warn("[Kyber] Key generation failed:", e);
-    return null;
-  }
+  const seed = randN(64);
+  const kp = ml_kem1024.keygen(seed);
+  return {
+    publicB64: b64(kp.publicKey),
+    secretB64: b64(kp.secretKey)
+  };
 }
 
 // src/vault/manager.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnituum/pqc-shared",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Omnituum PQC Shared Library - Crypto, Vault, File Encryption, and Utilities",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -31,25 +31,43 @@
       "types": "./dist/fs/index.d.ts",
       "import": "./dist/fs/index.js",
       "require": "./dist/fs/index.cjs"
+    },
+    "./safe": {
+      "types": "./dist/crypto/safe/index.d.ts",
+      "import": "./dist/crypto/safe/index.js",
+      "require": "./dist/crypto/safe/index.cjs"
     }
   },
   "files": [
     "dist",
     "src"
   ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "test:golden:generate": "pnpm -s build && tsx tests/golden/generate-vectors.ts",
+    "test:golden:verify": "pnpm -s build && tsx tests/golden/verify-vectors.ts",
+    "test:golden": "pnpm test:golden:verify",
+    "test": "vitest run tests/",
+    "test:watch": "vitest tests/",
+    "pretest": "pnpm build"
+  },
   "dependencies": {
     "@noble/ciphers": "~2.0.0",
     "@noble/hashes": "~2.0.0",
+    "@omnituum/envelope-registry": "github:Omnituum/envelope-registry#v0.1.2",
     "@noble/post-quantum": "~0.5.4",
     "hash-wasm": "^4.11.0",
-    "kyber-crystals": "^1.0.7",
     "tweetnacl": "^1.0.3"
   },
   "devDependencies": {
     "@types/node": "^25.0.9",
     "tsup": "^8.5.0",
     "tsx": "^4.19.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^3.1.0"
   },
   "keywords": [
     "pqc",
@@ -73,14 +91,10 @@
     "url": "https://github.com/Omnituum/pqc-shared/issues"
   },
   "homepage": "https://github.com/Omnituum/pqc-shared#readme",
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "clean": "rm -rf dist",
-    "typecheck": "tsc --noEmit",
-    "test:golden:generate": "pnpm -s build && tsx tests/golden/generate-vectors.ts",
-    "test:golden:verify": "pnpm -s build && tsx tests/golden/verify-vectors.ts",
-    "test:golden": "npm run test:golden:verify",
-    "pretest": "npm run build"
+  "packageManager": "pnpm@10.32.1",
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "@omnituum/envelope-registry"
+    ]
   }
-}
+}

package/src/crypto/dilithium.ts

@@ -140,7 +140,8 @@ export async function dilithiumSign(
   const sk = fromB64(secretKeyB64);
   const msg = typeof message === 'string' ? new TextEncoder().encode(message) : message;
 
-  const signature = mod.sign(sk, msg);
+  // noble API: sign(message, secretKey)
+  const signature = mod.sign(msg, sk);
 
   return {
     signature: toB64(signature),
@@ -160,7 +161,8 @@ export async function dilithiumSignRaw(
     throw new Error('Dilithium library not available');
   }
 
-  return mod.sign(secretKey, message);
+  // noble API: sign(message, secretKey)
+  return mod.sign(message, secretKey);
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -190,7 +192,8 @@ export async function dilithiumVerify(
   const msg = typeof message === 'string' ? new TextEncoder().encode(message) : message;
 
   try {
-    return mod.verify(pk, msg, sig);
+    // noble API: verify(signature, message, publicKey)
+    return mod.verify(sig, msg, pk);
   } catch {
     return false;
   }
@@ -210,7 +213,8 @@ export async function dilithiumVerifyRaw(
   }
 
   try {
-    return mod.verify(publicKey, message, signature);
+    // noble API: verify(signature, message, publicKey)
+    return mod.verify(signature, message, publicKey);
   } catch {
     return false;
   }

package/src/crypto/hybrid.ts

@@ -75,38 +75,22 @@ export interface HybridSecretKeys {
   kyberSecB64: string;
 }
 
-export interface HybridEnvelope {
-  /** Version identifier (FROZEN - see pqc-docs/specs/envelope.v1.md) */
-  v: typeof ENVELOPE_VERSION;
-  /** Algorithm suite */
-  suite: typeof ENVELOPE_SUITE;
-  /** AEAD algorithm */
-  aead: typeof ENVELOPE_AEAD;
-  /** X25519 ephemeral public key (hex) */
-  x25519Epk: string;
-  /** X25519 wrapped content key */
-  x25519Wrap: {
-    nonce: string;
-    wrapped: string;
-  };
-  /** Kyber KEM ciphertext (base64) */
-  kyberKemCt: string;
-  /** Kyber wrapped content key */
-  kyberWrap: {
-    nonce: string;
-    wrapped: string;
-  };
-  /** Content encryption nonce (base64) */
-  contentNonce: string;
-  /** Encrypted content (base64) */
-  ciphertext: string;
-  /** Metadata */
-  meta: {
-    createdAt: string;
+/**
+ * HybridEnvelope -- OmniHybridV1 from the registry with
+ * app-semantic meta fields (senderName, senderId).
+ * The Omni registry type defines only the crypto-relevant surface.
+ *
+ * Intentionally a type alias (not interface extends) to discourage
+ * further field additions here. New app-semantic fields belong in
+ * product-level types, not in the shared crypto layer.
+ */
+import type { OmniHybridV1 } from '@omnituum/envelope-registry';
+export type HybridEnvelope = Omit<OmniHybridV1, 'meta'> & {
+  meta: OmniHybridV1['meta'] & {
     senderName?: string;
     senderId?: string;
   };
-}
+};
 
 // ═══════════════════════════════════════════════════════════════════════════
 // HELPERS

package/src/crypto/index.ts

@@ -83,11 +83,14 @@ export type {
 export {
   isKyberAvailable,
   generateKyberKeypair,
+  generateKyberKeypairFromSeed,
   kyberEncapsulate,
   kyberDecapsulate,
   kyberWrapKey,
   kyberUnwrapKey,
+  KYBER_SUITE,
 } from './kyber';
+export type { KyberSuite } from './kyber';
 
 // ═══════════════════════════════════════════════════════════════════════════
 // DILITHIUM ML-DSA-65 (Post-Quantum Signatures)

package/src/crypto/kyber.ts

@@ -1,11 +1,25 @@
 /**
- * Omnituum PQC Shared - Kyber ML-KEM-768
+ * Omnituum PQC Shared — Kyber (ML-KEM-1024, FIPS 203)
  *
- * Browser-compatible Kyber operations using kyber-crystals.
- * NIST Level 3 security - quantum-resistant.
+ * Backend: @noble/post-quantum `ml_kem1024`. NIST FIPS 203 (final, 2024).
+ *
+ * Wire-format note: previous releases (<= 0.3.x) of this package were backed by
+ * `kyber-crystals`, which implements an earlier draft of Kyber and is NOT
+ * interoperable with FIPS 203 — see `tests/interop/historical/` and
+ * `package-docs/GAPS_AND_TASKS.md` (PQC-02 result). 0.4.0 is an intentional
+ * clean break: legacy draft-Kyber material cannot be read by this version.
+ *
+ * Sizes (ML-KEM-1024):
+ *   publicKey  1568 bytes
+ *   secretKey  3168 bytes
+ *   ciphertext 1568 bytes
+ *   sharedSecret 32 bytes
+ *
+ * Suite tag for new material: "ML-KEM-1024-FIPS203".
  */
 
-import { b64, ub64, sha256 } from './primitives';
+import { ml_kem1024 } from '@noble/post-quantum/ml-kem.js';
+import { b64, ub64, sha256, randN } from './primitives';
 import nacl from 'tweetnacl';
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -27,33 +41,21 @@ export interface KyberEncapsulation {
   sharedSecret: Uint8Array;
 }
 
-// ═══════════════════════════════════════════════════════════════════════════
-// KYBER LIBRARY LOADING
-// ═══════════════════════════════════════════════════════════════════════════
-
-let kyberModule: any = null;
-
-async function loadKyber(): Promise<any> {
-  if (kyberModule) return kyberModule;
-
-  try {
-    const m = await import('kyber-crystals');
-    const k = (m as any).default ?? m;
-    kyberModule = k.kyber ?? k;
-    return kyberModule;
-  } catch (e) {
-    console.warn('[Kyber] Failed to load kyber-crystals:', e);
-    return null;
-  }
-}
+/** Canonical suite identifier for new material produced by this package. */
+export const KYBER_SUITE = 'ML-KEM-1024-FIPS203' as const;
+export type KyberSuite = typeof KYBER_SUITE;
 
 // ═══════════════════════════════════════════════════════════════════════════
-// AVAILABILITY CHECK
+// AVAILABILITY
 // ═══════════════════════════════════════════════════════════════════════════
 
+/**
+ * @deprecated Always returns true. Retained for API stability across the
+ * 0.3.x → 0.4.x cut. The noble backend is statically imported and always
+ * present; there is no runtime feature-detection path.
+ */
 export async function isKyberAvailable(): Promise<boolean> {
-  const mod = await loadKyber();
-  return mod !== null;
+  return true;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -61,139 +63,79 @@ export async function isKyberAvailable(): Promise<boolean> {
 // ═══════════════════════════════════════════════════════════════════════════
 
 /**
- * Generate a Kyber ML-KEM-768 keypair.
+ * Generate a fresh ML-KEM-1024 keypair using a cryptographically random seed.
  */
 export async function generateKyberKeypair(): Promise<KyberKeypairB64 | null> {
-  try {
-    const mod = await loadKyber();
-    if (!mod) return null;
-
-    if (mod?.ready?.then) {
-      await mod.ready;
-    }
-
-    const fn = mod?.keypair ?? mod?.keyPair ?? mod?.generateKeyPair ?? null;
-    if (typeof fn !== 'function') {
-      console.warn('[Kyber] No keypair function found');
-      return null;
-    }
-
-    const kp = await fn.call(mod);
-    const pub = kp?.publicKey ?? kp?.public ?? kp?.pk;
-    const priv = kp?.privateKey ?? kp?.secretKey ?? kp?.secret ?? kp?.sk;
-
-    if (!pub || !priv) {
-      console.warn('[Kyber] Invalid keypair result');
-      return null;
-    }
-
-    return {
-      publicB64: b64(new Uint8Array(pub)),
-      secretB64: b64(new Uint8Array(priv)),
-    };
-  } catch (e) {
-    console.warn('[Kyber] Key generation failed:', e);
-    return null;
+  const seed = randN(64);
+  const kp = ml_kem1024.keygen(seed);
+  return {
+    publicB64: b64(kp.publicKey),
+    secretB64: b64(kp.secretKey),
+  };
+}
+
+/**
+ * Derive a deterministic ML-KEM-1024 keypair from a 64-byte seed.
+ * Same seed → byte-identical keypair, across runtimes (Node, browser).
+ *
+ * The seed is passed verbatim to the FIPS 203 keygen. Callers that need
+ * domain separation between Kyber and other key types must apply it
+ * upstream (e.g. via SHA-256 with a domain tag) before calling.
+ */
+export function generateKyberKeypairFromSeed(seed: Uint8Array): KyberKeypair {
+  if (seed.length !== 64) {
+    throw new Error('Kyber seed must be 64 bytes');
   }
+  const kp = ml_kem1024.keygen(seed);
+  return { publicKey: kp.publicKey, secretKey: kp.secretKey };
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
 // ENCAPSULATION / DECAPSULATION
 // ═══════════════════════════════════════════════════════════════════════════
 
-/**
- * Encapsulate a shared secret using Kyber ML-KEM-768.
- */
 export async function kyberEncapsulate(pubKeyB64: string): Promise<KyberEncapsulation> {
-  const kyber = await loadKyber();
-  if (!kyber?.encrypt) {
-    throw new Error('Kyber encrypt not available');
-  }
-
   const pk = ub64(pubKeyB64);
-  const r: any = await kyber.encrypt(pk);
-
-  // Normalize ciphertext
-  const ctRaw =
-    r?.ciphertext ?? r?.cyphertext ?? r?.ct ??
-    r?.bytes?.ciphertext ?? r?.bytes?.cyphertext ?? r?.bytes?.ct ??
-    (Array.isArray(r) ? r[0] : undefined);
-
-  // Normalize shared secret
-  const ssRaw =
-    r?.key ?? r?.sharedSecret ?? r?.secret ??
-    r?.bytes?.key ?? r?.bytes?.sharedSecret ??
-    (Array.isArray(r) ? r[1] : undefined);
-
-  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,
   };
 }
 
-/**
- * Decapsulate a shared secret using Kyber ML-KEM-768.
- */
 export async function kyberDecapsulate(
   kemCiphertextB64: string,
-  secretKeyB64: string
+  secretKeyB64: string,
 ): Promise<Uint8Array> {
-  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: any = 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);
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// KEY WRAPPING HELPERS
+// KEY WRAPPING (library-agnostic; NaCl secretbox over derived KEK)
 // ═══════════════════════════════════════════════════════════════════════════
 
-/**
- * Wrap a message key using Kyber shared secret.
- */
-export function kyberWrapKey(sharedSecret: Uint8Array, msgKey32: Uint8Array): {
-  nonce: string;
-  wrapped: string;
-} {
+export function kyberWrapKey(
+  sharedSecret: Uint8Array,
+  msgKey32: Uint8Array,
+): { nonce: string; wrapped: string } {
   if (msgKey32.length !== 32) {
     throw new Error('Message key must be 32 bytes');
   }
-
-  const kek = sha256(sharedSecret); // Derive KEK from shared secret
+  const kek = sha256(sharedSecret);
   const nonce = globalThis.crypto.getRandomValues(new Uint8Array(24));
   const wrapped = nacl.secretbox(msgKey32, nonce, kek);
-
-  return {
-    nonce: b64(nonce),
-    wrapped: b64(wrapped),
-  };
+  return { nonce: b64(nonce), wrapped: b64(wrapped) };
 }
 
-/**
- * Unwrap a message key using Kyber shared secret.
- */
 export function kyberUnwrapKey(
   sharedSecret: Uint8Array,
   nonceB64: string,
-  wrappedB64: string
+  wrappedB64: string,
 ): Uint8Array | null {
   const kek = sha256(sharedSecret);
   const nonce = ub64(nonceB64);
   const wrapped = ub64(wrappedB64);
-
   return nacl.secretbox.open(wrapped, nonce, kek) || null;
 }