@reallyme/crypto 0.3.8 → 0.3.10

package/dist/cryptoFacade.js

@@ -1,426 +1,30 @@
-// SPDX-FileCopyrightText: Copyright © 2026 ReallyMe LLC. All rights reserved
+// SPDX-FileCopyrightText: 2026 ReallyMe LLC
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
-import { ReallyMeAead } from "./aead.js";
-import { ReallyMeAesKw } from "./aesKw.js";
-import { ReallyMeArgon2id } from "./argon2id.js";
-import { ReallyMeBip340Schnorr } from "./bip340Schnorr.js";
-import { ReallyMeDigest } from "./digest.js";
-import { ReallyMeEd25519 } from "./ed25519.js";
+import { createReallyMeAsymmetricFacade } from "./cryptoFacadeAsymmetric.js";
+import { createReallyMeSymmetricFacade } from "./cryptoFacadeSymmetric.js";
 import { ReallyMeCryptoError } from "./errors.js";
-import { ReallyMeHkdf } from "./hkdf.js";
-import { ReallyMeHmac } from "./hmac.js";
-import { ReallyMeHpke } from "./hpke.js";
-import { ReallyMeJwaConcatKdf } from "./jwaConcatKdf.js";
-import { ReallyMeKmac } from "./kmac.js";
-import { ReallyMeMlDsa } from "./mlDsa.js";
-import { ReallyMeMlKem } from "./mlKem.js";
-import { ReallyMeP256Ecdsa } from "./p256Ecdsa.js";
-import { ReallyMeP256Ecdh } from "./p256Ecdh.js";
-import { ReallyMeP384Ecdsa } from "./p384Ecdsa.js";
-import { ReallyMeP384Ecdh } from "./p384Ecdh.js";
-import { ReallyMeP521Ecdsa } from "./p521Ecdsa.js";
-import { ReallyMeP521Ecdh } from "./p521Ecdh.js";
-import { ReallyMePbkdf2 } from "./pbkdf2.js";
-import { ReallyMeRsa } from "./rsa.js";
-import { ReallyMeSecp256k1 } from "./secp256k1.js";
-import { ReallyMeSlhDsa } from "./slhDsa.js";
-import { requireReallyMeWasmProvider } from "./wasmProvider.js";
-import { processOperationResponseJsonWithProvider, processOperationResponseWithProvider, } from "./operationResponse.js";
-import { ensureByteArray } from "./validateBytes.js";
-import { ReallyMeX25519 } from "./x25519.js";
-import { ReallyMeXWing } from "./xWing.js";
-const SECP256K1_ECDSA = "ECDSA-secp256k1-SHA256";
-const P256_ECDSA = "ECDSA-P256-SHA256";
-const P384_ECDSA = "ECDSA-P384-SHA384";
-const P521_ECDSA = "ECDSA-P521-SHA512";
-const BIP340_SCHNORR = "BIP340-Schnorr-secp256k1-SHA256";
-const ED25519 = "Ed25519";
+import { requireReallyMeWasmProvider, requireTrustedReallyMeWasmProvider } from "./wasmProvider.js";
 /**
  * Generic package facade. Algorithm-specific objects remain available for
  * callers that want direct provider access; this facade gives consumers a
  * stable typed route and rejects algorithm/operation combinations that the
  * selected method does not define.
  */
-const createReallyMeCryptoFacade = (resolveWasmProvider) => ({
-    /**
-     * Executes a generated binary request and returns a binary
-     * `CryptoOperationResponse`.
-     */
-    processOperationResponse(request) {
-        ensureByteArray(request);
-        return processOperationResponseWithProvider(resolveWasmProvider(), request);
-    },
-    /**
-     * Executes a permitted non-secret generated ProtoJSON request and returns
-     * the same binary `CryptoOperationResponse`. Secret-bearing selectors fail
-     * before JSON value deserialization.
-     */
-    processOperationResponseJson(requestJson) {
-        ensureByteArray(requestJson);
-        return processOperationResponseJsonWithProvider(resolveWasmProvider(), requestJson);
-    },
-    hash(algorithm, bytes) {
-        switch (algorithm) {
-            case "SHA2-256":
-                return ReallyMeDigest.sha256(bytes);
-            case "SHA2-384":
-                return ReallyMeDigest.sha384(bytes);
-            case "SHA2-512":
-                return ReallyMeDigest.sha512(bytes);
-            case "SHA3-224":
-                return ReallyMeDigest.sha3_224(bytes);
-            case "SHA3-256":
-                return ReallyMeDigest.sha3_256(bytes);
-            case "SHA3-384":
-                return ReallyMeDigest.sha3_384(bytes);
-            case "SHA3-512":
-                return ReallyMeDigest.sha3_512(bytes);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    seal(algorithm, key, nonce, aad, plaintext) {
-        switch (algorithm) {
-            case "AES-128-GCM":
-            case "AES-192-GCM":
-            case "AES-256-GCM":
-            case "AES-256-GCM-SIV":
-            case "ChaCha20-Poly1305":
-            case "XChaCha20-Poly1305":
-                return ReallyMeAead.sealWithProvider(resolveWasmProvider(), algorithm, key, nonce, aad, plaintext);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    open(algorithm, key, nonce, aad, ciphertextWithTag) {
-        switch (algorithm) {
-            case "AES-128-GCM":
-            case "AES-192-GCM":
-            case "AES-256-GCM":
-            case "AES-256-GCM-SIV":
-            case "ChaCha20-Poly1305":
-            case "XChaCha20-Poly1305":
-                return ReallyMeAead.openWithProvider(resolveWasmProvider(), algorithm, key, nonce, aad, ciphertextWithTag);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    authenticate(algorithm, key, message) {
-        switch (algorithm) {
-            case "HMAC-SHA-256":
-                return ReallyMeHmac.authenticateSha256(key, message);
-            case "HMAC-SHA-384":
-                return ReallyMeHmac.authenticateSha384(key, message);
-            case "HMAC-SHA-512":
-                return ReallyMeHmac.authenticateSha512(key, message);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    verifyMac(algorithm, tag, key, message) {
-        switch (algorithm) {
-            case "HMAC-SHA-256":
-                return ReallyMeHmac.verifySha256(tag, key, message);
-            case "HMAC-SHA-384":
-                return ReallyMeHmac.verifySha384(tag, key, message);
-            case "HMAC-SHA-512":
-                return ReallyMeHmac.verifySha512(tag, key, message);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    deriveArgon2id(kdfVersion, secret, salt) {
-        return ReallyMeArgon2id.deriveKeyWithProvider(resolveWasmProvider(), kdfVersion, secret, salt);
-    },
-    deriveKey(algorithm, password, salt, iterations, outputLength) {
-        switch (algorithm) {
-            case "PBKDF2-HMAC-SHA-256":
-                return ReallyMePbkdf2.deriveHmacSha256(password, salt, iterations, outputLength);
-            case "PBKDF2-HMAC-SHA-512":
-                return ReallyMePbkdf2.deriveHmacSha512(password, salt, iterations, outputLength);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    deriveHkdf(algorithm, inputKeyMaterial, salt, info, outputLength) {
-        switch (algorithm) {
-            case "HKDF-SHA256":
-                return ReallyMeHkdf.deriveSha256(inputKeyMaterial, salt, info, outputLength);
-            case "HKDF-SHA384":
-                return ReallyMeHkdf.deriveSha384(inputKeyMaterial, salt, info, outputLength);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    deriveJwaConcatKdfSha256(algorithm, sharedSecret, algorithmId, partyUInfo, partyVInfo, outputLength) {
-        switch (algorithm) {
-            case "JWA-CONCAT-KDF-SHA256":
-                return ReallyMeJwaConcatKdf.deriveSha256(sharedSecret, algorithmId, partyUInfo, partyVInfo, outputLength);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    deriveKmac256(algorithm, key, context, customization, outputLength) {
-        switch (algorithm) {
-            case "KMAC256":
-                return ReallyMeKmac.deriveKmac256WithProvider(resolveWasmProvider(), key, context, customization, outputLength);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    wrapKey(algorithm, wrappingKey, keyToWrap) {
-        switch (algorithm) {
-            case "AES-128-KW":
-            case "AES-192-KW":
-            case "AES-256-KW":
-                return ReallyMeAesKw.wrapKeyWithProvider(algorithm, resolveWasmProvider(), wrappingKey, keyToWrap);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    unwrapKey(algorithm, wrappingKey, wrappedKey) {
-        switch (algorithm) {
-            case "AES-128-KW":
-            case "AES-192-KW":
-            case "AES-256-KW":
-                return ReallyMeAesKw.unwrapKeyWithProvider(algorithm, resolveWasmProvider(), wrappingKey, wrappedKey);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    generateKeyPair(algorithm) {
-        if (algorithm === ED25519) {
-            return ReallyMeEd25519.generateKeyPair();
-        }
-        switch (algorithm) {
-            case P256_ECDSA:
-                return ReallyMeP256Ecdsa.generateKeyPair();
-            case P384_ECDSA:
-                return ReallyMeP384Ecdsa.generateKeyPair();
-            case P521_ECDSA:
-                return ReallyMeP521Ecdsa.generateKeyPair();
-            case SECP256K1_ECDSA:
-                return ReallyMeSecp256k1.generateKeyPair();
-            case BIP340_SCHNORR:
-                return ReallyMeBip340Schnorr.generateKeyPair();
-            case "ML-DSA-44":
-            case "ML-DSA-65":
-            case "ML-DSA-87":
-                return ReallyMeMlDsa.generateKeyPairWithProvider(resolveWasmProvider(), algorithm);
-            case "SLH-DSA-SHA2-128s":
-                return ReallyMeSlhDsa.generateKeyPairWithProvider(resolveWasmProvider(), algorithm);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    deriveKeyPair(algorithm, secretKey) {
-        // Import an existing secret and reconstruct its public key. Do not use
-        // this as key generation from passwords or other low-entropy input; use
-        // generateKeyPair for new keys, or a protocol-approved KDF before import.
-        if (algorithm === ED25519) {
-            return ReallyMeEd25519.deriveKeyPair(secretKey);
-        }
-        switch (algorithm) {
-            case P256_ECDSA:
-                return ReallyMeP256Ecdsa.deriveKeyPair(secretKey);
-            case P384_ECDSA:
-                return ReallyMeP384Ecdsa.deriveKeyPair(secretKey);
-            case P521_ECDSA:
-                return ReallyMeP521Ecdsa.deriveKeyPair(secretKey);
-            case SECP256K1_ECDSA:
-                return ReallyMeSecp256k1.deriveKeyPair(secretKey);
-            case BIP340_SCHNORR:
-                return ReallyMeBip340Schnorr.deriveKeyPair(secretKey);
-            case "ML-DSA-44":
-            case "ML-DSA-65":
-            case "ML-DSA-87":
-                return ReallyMeMlDsa.deriveKeyPairWithProvider(resolveWasmProvider(), algorithm, secretKey);
-            case "SLH-DSA-SHA2-128s":
-                // SLH-DSA deterministic derivation uses three FIPS seed components,
-                // so it deliberately does not fit this single-secret import shape.
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    sign(algorithm, message, secretKey) {
-        if (algorithm === ED25519) {
-            return ReallyMeEd25519.sign(message, secretKey);
-        }
-        switch (algorithm) {
-            case P256_ECDSA:
-                return ReallyMeP256Ecdsa.sign(message, secretKey);
-            case P384_ECDSA:
-                return ReallyMeP384Ecdsa.sign(message, secretKey);
-            case P521_ECDSA:
-                return ReallyMeP521Ecdsa.sign(message, secretKey);
-            case SECP256K1_ECDSA:
-                return ReallyMeSecp256k1.sign(message, secretKey);
-            case "ML-DSA-44":
-            case "ML-DSA-65":
-            case "ML-DSA-87":
-                return ReallyMeMlDsa.signWithProvider(resolveWasmProvider(), algorithm, message, secretKey);
-            case "SLH-DSA-SHA2-128s":
-                return ReallyMeSlhDsa.signWithProvider(resolveWasmProvider(), algorithm, message, secretKey);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    signBip340Schnorr(message32, secretKey, auxRand32) {
-        return ReallyMeBip340Schnorr.sign(message32, secretKey, auxRand32);
-    },
-    verify(algorithm, signature, message, publicKey) {
-        if (algorithm === ED25519) {
-            ReallyMeEd25519.verify(signature, message, publicKey);
-            return;
-        }
-        switch (algorithm) {
-            case P256_ECDSA:
-                ReallyMeP256Ecdsa.verify(signature, message, publicKey);
-                return;
-            case P384_ECDSA:
-                ReallyMeP384Ecdsa.verify(signature, message, publicKey);
-                return;
-            case P521_ECDSA:
-                ReallyMeP521Ecdsa.verify(signature, message, publicKey);
-                return;
-            case SECP256K1_ECDSA:
-                ReallyMeSecp256k1.verify(signature, message, publicKey);
-                return;
-            case BIP340_SCHNORR:
-                ReallyMeBip340Schnorr.verify(signature, message, publicKey);
-                return;
-            case "ML-DSA-44":
-            case "ML-DSA-65":
-            case "ML-DSA-87":
-                ReallyMeMlDsa.verifyWithProvider(resolveWasmProvider(), algorithm, signature, message, publicKey);
-                return;
-            case "SLH-DSA-SHA2-128s":
-                ReallyMeSlhDsa.verifyWithProvider(resolveWasmProvider(), algorithm, signature, message, publicKey);
-                return;
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    verifyRsa(algorithm, signature, message, publicKeyDer, publicKeyEncoding) {
-        switch (algorithm) {
-            case "RSA-PKCS1v15-SHA1":
-            case "RSA-PKCS1v15-SHA256":
-            case "RSA-PKCS1v15-SHA384":
-            case "RSA-PKCS1v15-SHA512":
-            case "RSA-PSS-SHA1-MGF1-SHA1":
-            case "RSA-PSS-SHA256-MGF1-SHA256":
-            case "RSA-PSS-SHA384-MGF1-SHA384":
-            case "RSA-PSS-SHA512-MGF1-SHA512":
-                ReallyMeRsa.verifyWithProvider(resolveWasmProvider(), algorithm, signature, message, publicKeyDer, publicKeyEncoding);
-                return;
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    deriveSharedSecret(algorithm, publicKey, secretKey) {
-        switch (algorithm) {
-            case "X25519":
-                return ReallyMeX25519.deriveSharedSecret(publicKey, secretKey);
-            case "P-256-ECDH":
-                return ReallyMeP256Ecdh.deriveSharedSecret(publicKey, secretKey);
-            case "P-384-ECDH":
-                return ReallyMeP384Ecdh.deriveSharedSecret(publicKey, secretKey);
-            case "P-521-ECDH":
-                return ReallyMeP521Ecdh.deriveSharedSecret(publicKey, secretKey);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    deriveKeyAgreementKeyPair(algorithm, secretKey) {
-        switch (algorithm) {
-            case "X25519":
-                return ReallyMeX25519.deriveKeyPair(secretKey);
-            case "P-256-ECDH":
-                return ReallyMeP256Ecdh.deriveKeyPair(secretKey);
-            case "P-384-ECDH":
-                return ReallyMeP384Ecdh.deriveKeyPair(secretKey);
-            case "P-521-ECDH":
-                return ReallyMeP521Ecdh.deriveKeyPair(secretKey);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    generateKemKeyPair(algorithm) {
-        switch (algorithm) {
-            case "X-Wing-768":
-                return ReallyMeXWing.generateKeyPairWithProvider(resolveWasmProvider(), algorithm);
-            case "ML-KEM-512":
-            case "ML-KEM-768":
-            case "ML-KEM-1024":
-                return ReallyMeMlKem.generateKeyPairWithProvider(resolveWasmProvider(), algorithm);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    deriveKemKeyPair(algorithm, secretKey) {
-        switch (algorithm) {
-            case "X-Wing-768":
-                return ReallyMeXWing.deriveKeyPairWithProvider(resolveWasmProvider(), algorithm, secretKey);
-            case "ML-KEM-512":
-            case "ML-KEM-768":
-            case "ML-KEM-1024":
-                return ReallyMeMlKem.deriveKeyPairWithProvider(resolveWasmProvider(), algorithm, secretKey);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    encapsulate(algorithm, publicKey) {
-        switch (algorithm) {
-            case "X-Wing-768":
-                return ReallyMeXWing.encapsulateWithProvider(resolveWasmProvider(), algorithm, publicKey);
-            case "ML-KEM-512":
-            case "ML-KEM-768":
-            case "ML-KEM-1024":
-                return ReallyMeMlKem.encapsulateWithProvider(resolveWasmProvider(), algorithm, publicKey);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    decapsulate(algorithm, ciphertext, secretKey) {
-        switch (algorithm) {
-            case "X-Wing-768":
-                return ReallyMeXWing.decapsulateWithProvider(resolveWasmProvider(), algorithm, ciphertext, secretKey);
-            case "ML-KEM-512":
-            case "ML-KEM-768":
-            case "ML-KEM-1024":
-                return ReallyMeMlKem.decapsulateWithProvider(resolveWasmProvider(), algorithm, ciphertext, secretKey);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    sealHpke(suite, recipientPublicKey, info, aad, plaintext) {
-        switch (suite) {
-            case "DHKEM-P256-HKDF-SHA256-HKDF-SHA256-AES-256-GCM":
-            case "DHKEM-X25519-HKDF-SHA256-HKDF-SHA256-CHACHA20-POLY1305":
-                return ReallyMeHpke.sealBaseWithProvider(resolveWasmProvider(), suite, recipientPublicKey, info, aad, plaintext);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
-    openHpke(suite, recipientSecretKey, encapsulatedKey, info, aad, ciphertext) {
-        switch (suite) {
-            case "DHKEM-P256-HKDF-SHA256-HKDF-SHA256-AES-256-GCM":
-            case "DHKEM-X25519-HKDF-SHA256-HKDF-SHA256-CHACHA20-POLY1305":
-                return ReallyMeHpke.openBaseWithProvider(resolveWasmProvider(), suite, recipientSecretKey, encapsulatedKey, info, aad, ciphertext);
-            default:
-                throw new ReallyMeCryptoError("unsupported-algorithm");
-        }
-    },
+export const createReallyMeCryptoFacade = (resolveWasmProvider) => Object.freeze({
+    ...createReallyMeSymmetricFacade(resolveWasmProvider),
+    ...createReallyMeAsymmetricFacade(resolveWasmProvider),
 });
 export const createReallyMeCrypto = (providers = {}) => {
     const configuredProvider = providers.wasmProvider;
+    const trustedProvider = configuredProvider === undefined
+        ? undefined
+        : requireTrustedReallyMeWasmProvider(configuredProvider);
     return createReallyMeCryptoFacade(() => {
-        if (configuredProvider === undefined) {
+        if (trustedProvider === undefined) {
             throw new ReallyMeCryptoError("provider-failure");
         }
-        return configuredProvider;
+        return trustedProvider;
     });
 };
 export const ReallyMeCrypto = createReallyMeCryptoFacade(requireReallyMeWasmProvider);

package/dist/cryptoFacadeAsymmetric.d.ts

@@ -0,0 +1,20 @@
+import type { ReallyMeHpkeSuite, ReallyMeKemAlgorithm, ReallyMeKeyAgreementAlgorithm, ReallyMeSignatureAlgorithm } from "./algorithms.js";
+import type { ReallyMeHpkeSealedMessage, ReallyMeKemEncapsulation, ReallyMeKemKeyPair, ReallyMeKeyAgreementKeyPair, ReallyMeSignatureKeyPair } from "./cryptoFacade.js";
+import type { ReallyMeRsaPublicKeyDerEncoding } from "./rsa.js";
+import type { ReallyMeWasmProvider } from "./wasmProvider.js";
+export declare const createReallyMeAsymmetricFacade: (resolveWasmProvider: () => ReallyMeWasmProvider) => {
+    generateKeyPair(algorithm: ReallyMeSignatureAlgorithm): ReallyMeSignatureKeyPair;
+    deriveKeyPair(algorithm: ReallyMeSignatureAlgorithm, secretKey: Uint8Array): ReallyMeSignatureKeyPair;
+    sign(algorithm: ReallyMeSignatureAlgorithm, message: Uint8Array, secretKey: Uint8Array): Uint8Array;
+    signBip340Schnorr(message32: Uint8Array, secretKey: Uint8Array, auxRand32: Uint8Array): Uint8Array;
+    verify(algorithm: ReallyMeSignatureAlgorithm, signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array): void;
+    verifyRsa(algorithm: ReallyMeSignatureAlgorithm, signature: Uint8Array, message: Uint8Array, publicKeyDer: Uint8Array, publicKeyEncoding: ReallyMeRsaPublicKeyDerEncoding): void;
+    deriveSharedSecret(algorithm: ReallyMeKeyAgreementAlgorithm, publicKey: Uint8Array, secretKey: Uint8Array): Uint8Array;
+    deriveKeyAgreementKeyPair(algorithm: ReallyMeKeyAgreementAlgorithm, secretKey: Uint8Array): ReallyMeKeyAgreementKeyPair;
+    generateKemKeyPair(algorithm: ReallyMeKemAlgorithm): ReallyMeKemKeyPair;
+    deriveKemKeyPair(algorithm: ReallyMeKemAlgorithm, secretKey: Uint8Array): ReallyMeKemKeyPair;
+    encapsulate(algorithm: ReallyMeKemAlgorithm, publicKey: Uint8Array): ReallyMeKemEncapsulation;
+    decapsulate(algorithm: ReallyMeKemAlgorithm, ciphertext: Uint8Array, secretKey: Uint8Array): Uint8Array;
+    sealHpke(suite: ReallyMeHpkeSuite, recipientPublicKey: Uint8Array, info: Uint8Array, aad: Uint8Array, plaintext: Uint8Array): ReallyMeHpkeSealedMessage;
+    openHpke(suite: ReallyMeHpkeSuite, recipientSecretKey: Uint8Array, encapsulatedKey: Uint8Array, info: Uint8Array, aad: Uint8Array, ciphertext: Uint8Array): Uint8Array;
+};