@zudojs/crypto 0.1.0 → 1.1.0

package/dist/node/nodeCryptoProvider/nodeCryptoProvider.core.js

@@ -4,7 +4,6 @@ import { sign as signImpl, verify as verifyImpl, } from "./primitives/nodeCrypto
 import { deriveKey as deriveKeyImpl } from "./operations/nodeCryptoProvider.derivation.js";
 import { hashPassword as hashPasswordImpl, verifyPassword as verifyPasswordImpl, } from "./operations/nodeCryptoProvider.password.js";
 import { randomBytesImpl, randomIntImpl, randomUUIDImpl, } from "./primitives/nodeCryptoProvider.random.js";
-import { cryptoHashError, cryptoCipherError, cryptoSignatureError, cryptoKeyDerivationError, } from "@zudojs/errors";
 export class NodeCryptoProvider {
     name = "node";
     capabilities = {

package/dist/node/nodeCryptoProvider/nodeCryptoProvider.helper.d.ts

@@ -1,8 +1,13 @@
 import type { HashAlgorithm, HmacAlgorithm } from "../../cryptoProvider/index.js";
-import type { SignatureAlgorithm } from "../../cryptoProvider/index.js";
+/**
+ * Normalizes any `CryptoInput` into bytes (strings are UTF-8 encoded).
+ */
 export declare function toBytes(input: Uint8Array | string | ArrayBuffer): Uint8Array;
+/**
+ * Maps a package hash algorithm name to the OpenSSL digest name.
+ *
+ * Only the allowlisted algorithms are accepted; anything else (md5, sha1,
+ * arbitrary strings from configuration) throws.
+ */
 export declare function nodeHashAlgorithm(algorithm: HashAlgorithm | HmacAlgorithm): string;
-export declare function nodeSignatureAlgorithm(algorithm: SignatureAlgorithm): string;
-export declare function toBase64Url(bytes: Uint8Array): string;
-export declare function fromBase64Url(value: string): Uint8Array;
 //# sourceMappingURL=nodeCryptoProvider.helper.d.ts.map

package/dist/node/nodeCryptoProvider/nodeCryptoProvider.helper.js

@@ -1,3 +1,6 @@
+/**
+ * Normalizes any `CryptoInput` into bytes (strings are UTF-8 encoded).
+ */
 export function toBytes(input) {
     if (input instanceof Uint8Array) {
         return input;
@@ -5,51 +8,30 @@ export function toBytes(input) {
     if (typeof input === "string") {
         return new Uint8Array(Buffer.from(input, "utf8"));
     }
-    return new Uint8Array(input);
-}
-export function nodeHashAlgorithm(algorithm) {
-    const map = {
-        sha256: "sha256",
-        sha384: "sha384",
-        sha512: "sha512",
-        "sha3-256": "sha3-256",
-        "sha3-384": "sha3-384",
-        "sha3-512": "sha3-512",
-    };
-    return map[algorithm] ?? algorithm;
-}
-export function nodeSignatureAlgorithm(algorithm) {
-    switch (algorithm) {
-        case "rsa-sha256":
-            return "RSA-SHA256";
-        case "rsa-sha384":
-            return "RSA-SHA384";
-        case "rsa-sha512":
-            return "RSA-SHA512";
-        case "ecdsa-sha256":
-            return "ecdsa-SHA256";
-        case "ecdsa-sha384":
-            return "ecdsa-SHA384";
-        case "ecdsa-sha512":
-            return "ecdsa-SHA512";
-        case "ed25519":
-            return "ed25519";
-        default:
-            throw new TypeError(`Unsupported signature algorithm: ${algorithm}.`);
+    if (input instanceof ArrayBuffer) {
+        return new Uint8Array(input);
     }
+    throw new TypeError("Input must be a string, Uint8Array, or ArrayBuffer.");
 }
-export function toBase64Url(bytes) {
-    return Buffer.from(bytes)
-        .toString("base64")
-        .replace(/\+/g, "-")
-        .replace(/\//g, "_")
-        .replace(/=/g, "");
-}
-export function fromBase64Url(value) {
-    let base64 = value.replace(/-/g, "+").replace(/_/g, "/");
-    while (base64.length % 4 !== 0) {
-        base64 += "=";
+const NODE_HASH_ALGORITHMS = Object.freeze({
+    sha256: "sha256",
+    sha384: "sha384",
+    sha512: "sha512",
+    "sha3-256": "sha3-256",
+    "sha3-384": "sha3-384",
+    "sha3-512": "sha3-512",
+});
+/**
+ * Maps a package hash algorithm name to the OpenSSL digest name.
+ *
+ * Only the allowlisted algorithms are accepted; anything else (md5, sha1,
+ * arbitrary strings from configuration) throws.
+ */
+export function nodeHashAlgorithm(algorithm) {
+    const name = typeof algorithm === "string" ? NODE_HASH_ALGORITHMS[algorithm] : undefined;
+    if (name === undefined) {
+        throw new TypeError(`Unsupported hash algorithm: ${String(algorithm)}.`);
     }
-    return new Uint8Array(Buffer.from(base64, "base64"));
+    return name;
 }
 //# sourceMappingURL=nodeCryptoProvider.helper.js.map

package/dist/node/nodeCryptoProvider/operations/nodeCryptoProvider.derivation.d.ts

@@ -1,3 +1,10 @@
 import type { DeriveKeyOptions } from "../../../cryptoProvider/index.js";
+/**
+ * Computes a memory bound for scrypt from its parameters.
+ *
+ * OpenSSL requires roughly `128 * N * r` bytes plus `128 * r * p`; we
+ * double that for margin and never go below Node's own 32 MiB default.
+ */
+export declare function defaultScryptMaxMemory(N: number, r: number, p: number): number;
 export declare function deriveKey(options: DeriveKeyOptions): Promise<Uint8Array>;
 //# sourceMappingURL=nodeCryptoProvider.derivation.d.ts.map

package/dist/node/nodeCryptoProvider/operations/nodeCryptoProvider.derivation.js

@@ -1,45 +1,127 @@
-import { pbkdf2, scrypt, randomBytes, timingSafeEqual } from "node:crypto";
-import { toBytes, toBase64Url, fromBase64Url, } from "../nodeCryptoProvider.helper.js";
-import { cryptoKeyDerivationError } from "@zudojs/errors";
-export async function deriveKey(options) {
+import { isPbkdf2Digest } from "../../../cryptoProvider/cryptoProvider.type.js";
+import { pbkdf2, scrypt } from "node:crypto";
+import { toBytes } from "../nodeCryptoProvider.helper.js";
+import { keyDerivationError } from "../../../cryptoErrors/cryptoErrors.helper.js";
+import { PASSWORD_HASH } from "../../../cryptoConstants/cryptoConstants.security.js";
+/** Hard floors applied at the provider boundary. */
+const PROVIDER_MIN_SALT_BYTES = 16;
+const PROVIDER_MIN_KEY_BYTES = 16;
+const PROVIDER_MIN_PBKDF2_ITERATIONS = 1_000;
+/**
+ * Hard ceilings applied at the provider boundary.
+ *
+ * The provider is reachable directly (`provider.deriveKey`) and through
+ * custom wrappers, so the same `PASSWORD_HASH.LIMITS` that bound stored
+ * password hashes are enforced here too. Without them the scrypt memory
+ * bound was computed from the requested cost, which is no bound at all.
+ */
+const PROVIDER_LIMITS = PASSWORD_HASH.LIMITS;
+const DEFAULT_PBKDF2_ITERATIONS = 600_000;
+const DEFAULT_SCRYPT_COST = 16_384;
+const DEFAULT_SCRYPT_BLOCK_SIZE = 8;
+const DEFAULT_SCRYPT_PARALLELISM = 1;
+const NODE_DEFAULT_MAXMEM = 32 * 1024 * 1024;
+/**
+ * Computes a memory bound for scrypt from its parameters.
+ *
+ * OpenSSL requires roughly `128 * N * r` bytes plus `128 * r * p`; we
+ * double that for margin and never go below Node's own 32 MiB default.
+ */
+export function defaultScryptMaxMemory(N, r, p) {
+    return Math.max(NODE_DEFAULT_MAXMEM, 2 * (128 * N * r + 128 * r * p));
+}
+function validateCommon(options, algorithm) {
     const password = toBytes(options.password);
     const salt = options.salt;
+    const keyLength = options.keyLength ?? 32;
+    if (!(salt instanceof Uint8Array) || salt.byteLength < PROVIDER_MIN_SALT_BYTES) {
+        throw keyDerivationError(`Salt must be at least ${PROVIDER_MIN_SALT_BYTES} bytes.`, algorithm);
+    }
+    if (!Number.isInteger(keyLength) ||
+        keyLength < PROVIDER_MIN_KEY_BYTES ||
+        keyLength > PROVIDER_LIMITS.MAX_DERIVED_KEY_BYTES) {
+        throw keyDerivationError(`keyLength must be an integer between ${PROVIDER_MIN_KEY_BYTES} and ${PROVIDER_LIMITS.MAX_DERIVED_KEY_BYTES}.`, algorithm);
+    }
+    return { password, salt, keyLength };
+}
+export async function deriveKey(options) {
     switch (options.algorithm) {
         case "pbkdf2": {
+            const { password, salt, keyLength } = validateCommon(options, "pbkdf2");
+            const iterations = options.iterations ?? DEFAULT_PBKDF2_ITERATIONS;
+            const digest = options.digest ?? "sha256";
+            if (!Number.isInteger(iterations) ||
+                iterations < PROVIDER_MIN_PBKDF2_ITERATIONS ||
+                iterations > PROVIDER_LIMITS.MAX_PBKDF2_ITERATIONS) {
+                throw keyDerivationError(`PBKDF2 iterations must be an integer between ${PROVIDER_MIN_PBKDF2_ITERATIONS} and ${PROVIDER_LIMITS.MAX_PBKDF2_ITERATIONS}.`, "pbkdf2");
+            }
+            if (!isPbkdf2Digest(digest)) {
+                throw keyDerivationError(`Unsupported PBKDF2 digest: ${String(digest)}.`, "pbkdf2");
+            }
             return new Promise((resolve, reject) => {
-                const keyLength = options.keyLength ?? 32;
-                pbkdf2(Buffer.from(password), Buffer.from(salt), options.iterations ?? 100_000, keyLength, "sha256", (err, derived) => {
-                    if (err) {
-                        reject(cryptoKeyDerivationError("Key derivation failed.", "pbkdf2"));
-                    }
-                    else {
-                        resolve(new Uint8Array(derived));
-                    }
-                });
+                try {
+                    pbkdf2(Buffer.from(password), Buffer.from(salt), iterations, keyLength, digest, (err, derived) => {
+                        if (err) {
+                            reject(keyDerivationError("Key derivation failed.", "pbkdf2", err));
+                        }
+                        else {
+                            resolve(new Uint8Array(derived));
+                        }
+                    });
+                }
+                catch (error) {
+                    reject(keyDerivationError("Key derivation failed.", "pbkdf2", error));
+                }
             });
         }
         case "scrypt": {
+            const { password, salt, keyLength } = validateCommon(options, "scrypt");
+            const N = options.memoryCost ?? DEFAULT_SCRYPT_COST;
+            const r = options.blockSize ?? DEFAULT_SCRYPT_BLOCK_SIZE;
+            const p = options.parallelism ?? DEFAULT_SCRYPT_PARALLELISM;
+            if (!Number.isInteger(N) ||
+                N < 2 ||
+                N > PROVIDER_LIMITS.MAX_SCRYPT_COST ||
+                (N & (N - 1)) !== 0) {
+                throw keyDerivationError(`scrypt cost must be a power of two between 2 and ${PROVIDER_LIMITS.MAX_SCRYPT_COST}.`, "scrypt");
+            }
+            if (!Number.isInteger(r) ||
+                r <= 0 ||
+                r > PROVIDER_LIMITS.MAX_SCRYPT_BLOCK_SIZE) {
+                throw keyDerivationError(`scrypt blockSize must be an integer between 1 and ${PROVIDER_LIMITS.MAX_SCRYPT_BLOCK_SIZE}.`, "scrypt");
+            }
+            if (!Number.isInteger(p) ||
+                p <= 0 ||
+                p > PROVIDER_LIMITS.MAX_SCRYPT_PARALLELIZATION) {
+                throw keyDerivationError(`scrypt parallelism must be an integer between 1 and ${PROVIDER_LIMITS.MAX_SCRYPT_PARALLELIZATION}.`, "scrypt");
+            }
+            if (128 * N * r > PROVIDER_LIMITS.MAX_SCRYPT_MEMORY_BYTES) {
+                throw keyDerivationError(`scrypt cost * blockSize exceeds the memory bound of ${PROVIDER_LIMITS.MAX_SCRYPT_MEMORY_BYTES} bytes.`, "scrypt");
+            }
+            const maxmem = options.maxMemory ?? defaultScryptMaxMemory(N, r, p);
+            if (!Number.isInteger(maxmem) || maxmem <= 0) {
+                throw keyDerivationError("scrypt maxMemory must be a positive integer.", "scrypt");
+            }
             return new Promise((resolve, reject) => {
-                const keyLength = options.keyLength ?? 32;
-                scrypt(Buffer.from(password), Buffer.from(salt), keyLength, {
-                    N: options.memoryCost ?? 16384,
-                    r: 8,
-                    p: options.parallelism ?? 1,
-                }, (err, derived) => {
-                    if (err) {
-                        reject(cryptoKeyDerivationError("Key derivation failed.", "scrypt"));
-                    }
-                    else {
-                        resolve(new Uint8Array(derived));
-                    }
-                });
+                try {
+                    scrypt(Buffer.from(password), Buffer.from(salt), keyLength, { N, r, p, maxmem }, (err, derived) => {
+                        if (err) {
+                            reject(keyDerivationError("Key derivation failed.", "scrypt", err));
+                        }
+                        else {
+                            resolve(new Uint8Array(derived));
+                        }
+                    });
+                }
+                catch (error) {
+                    reject(keyDerivationError("Key derivation failed.", "scrypt", error));
+                }
             });
         }
-        case "argon2id": {
-            throw new TypeError("Argon2id requires the argon2 package.");
-        }
         default:
-            throw new TypeError(`Unsupported key derivation algorithm: ${options.algorithm}.`);
+            throw keyDerivationError(`Unsupported key derivation algorithm: ${String(options.algorithm)}.`, typeof options.algorithm === "string"
+                ? String(options.algorithm)
+                : undefined);
     }
 }
 //# sourceMappingURL=nodeCryptoProvider.derivation.js.map

package/dist/node/nodeCryptoProvider/operations/nodeCryptoProvider.password.d.ts

@@ -1,12 +1,19 @@
-import type { CryptoInput, KeyDerivationAlgorithm } from "../../../cryptoProvider/index.js";
-export declare function hashPassword(password: CryptoInput, options?: {
-    algorithm?: KeyDerivationAlgorithm;
-    memoryCost?: number;
-    timeCost?: number;
-    blockSize?: number;
-    parallelism?: number;
-    keyBytes?: number;
-    salt?: Uint8Array;
-}): Promise<string>;
+import type { CryptoInput, PasswordHashProviderOptions } from "../../../cryptoProvider/index.js";
+/**
+ * Hashes a password with scrypt (default) or PBKDF2 and returns the
+ * self-describing, versioned encoding produced by `encodePasswordHash`.
+ *
+ * The encoded string is validated against `PASSWORD_HASH.LIMITS`, so the
+ * provider refuses insecure parameters (short salts, tiny work factors)
+ * instead of producing a hash that can never be verified.
+ */
+export declare function hashPassword(password: CryptoInput, options?: PasswordHashProviderOptions): Promise<string>;
+/**
+ * Verifies a password against an encoded hash.
+ *
+ * Returns false for any malformed, foreign or out-of-bounds hash string
+ * instead of throwing, so login paths fail closed. The hash is decoded
+ * and validated before any derivation work is done.
+ */
 export declare function verifyPassword(password: CryptoInput, hash: string): Promise<boolean>;
 //# sourceMappingURL=nodeCryptoProvider.password.d.ts.map

package/dist/node/nodeCryptoProvider/operations/nodeCryptoProvider.password.js

@@ -1,94 +1,134 @@
-import { randomBytes, pbkdf2, scrypt, timingSafeEqual } from "node:crypto";
-import { toBytes, toBase64Url, fromBase64Url, } from "../nodeCryptoProvider.helper.js";
-import { PASSWORD_FORMAT_VERSION } from "../../../cryptoPassword/cryptoPassword.codec.js";
-import { decodePasswordHash } from "../../../cryptoPassword/cryptoPassword.codec.js";
+import { randomBytes } from "node:crypto";
+import { toBytes } from "../nodeCryptoProvider.helper.js";
+import { timingSafeEqual } from "../../../compare/compare.helper.js";
+import { CryptoAlgorithm } from "../../../cryptoConstants/cryptoConstants.type.js";
+import { PASSWORD_HASH } from "../../../cryptoConstants/cryptoConstants.security.js";
+import { PASSWORD_FORMAT_VERSION, decodePasswordHash, encodePasswordHash, pbkdf2PasswordAlgorithm, } from "../../../cryptoPassword/cryptoPassword.codec.js";
+import { deriveKey } from "./nodeCryptoProvider.derivation.js";
+import { keyDerivationError } from "../../../cryptoErrors/cryptoErrors.helper.js";
+/**
+ * Hashes a password with scrypt (default) or PBKDF2 and returns the
+ * self-describing, versioned encoding produced by `encodePasswordHash`.
+ *
+ * The encoded string is validated against `PASSWORD_HASH.LIMITS`, so the
+ * provider refuses insecure parameters (short salts, tiny work factors)
+ * instead of producing a hash that can never be verified.
+ */
 export async function hashPassword(password, options) {
     const algorithm = options?.algorithm ?? "scrypt";
-    const salt = options?.salt ?? randomBytes(16);
-    const blockSize = options?.blockSize ?? 8;
-    const keyBytes = options?.keyBytes ?? 32;
-    let hash;
+    const salt = options?.salt ?? new Uint8Array(randomBytes(PASSWORD_HASH.SALT_BYTES));
+    const keyBytes = options?.keyBytes ?? PASSWORD_HASH.KEY_BYTES;
+    const passwordBytes = toBytes(password);
     switch (algorithm) {
         case "scrypt": {
-            const passwordBytes = toBytes(password);
-            hash = await new Promise((resolve, reject) => {
-                scrypt(passwordBytes, salt, keyBytes, {
-                    N: options?.memoryCost ?? 16384,
-                    r: blockSize,
-                    p: options?.parallelism ?? 1,
-                }, (err, derived) => {
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        resolve(new Uint8Array(derived));
-                    }
-                });
+            const cost = options?.memoryCost ?? PASSWORD_HASH.SCRYPT.COST;
+            const blockSize = options?.blockSize ?? PASSWORD_HASH.SCRYPT.BLOCK_SIZE;
+            const parallelization = options?.parallelism ?? PASSWORD_HASH.SCRYPT.PARALLELIZATION;
+            // Validate before deriving so invalid parameters fail fast.
+            const placeholder = new Uint8Array(keyBytes);
+            encodePasswordHash({
+                version: PASSWORD_FORMAT_VERSION,
+                algorithm: CryptoAlgorithm.SCRYPT,
+                salt,
+                hash: placeholder,
+                cost,
+                blockSize,
+                parallelization,
+            });
+            const hash = await deriveKey({
+                password: passwordBytes,
+                salt,
+                algorithm: "scrypt",
+                keyLength: keyBytes,
+                memoryCost: cost,
+                blockSize,
+                parallelism: parallelization,
+            });
+            return encodePasswordHash({
+                version: PASSWORD_FORMAT_VERSION,
+                algorithm: CryptoAlgorithm.SCRYPT,
+                salt,
+                hash,
+                cost,
+                blockSize,
+                parallelization,
             });
-            break;
-        }
-        case "argon2id": {
-            throw new TypeError("Argon2id requires the argon2 package.");
         }
         case "pbkdf2": {
-            const passwordBytes = toBytes(password);
-            hash = await new Promise((resolve, reject) => {
-                pbkdf2(passwordBytes, salt, options?.timeCost ?? 100_000, keyBytes, "sha256", (err, derived) => {
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        resolve(new Uint8Array(derived));
-                    }
-                });
+            const iterations = options?.timeCost ?? PASSWORD_HASH.PBKDF2.ITERATIONS;
+            const digest = options?.digest ?? "sha256";
+            const label = pbkdf2PasswordAlgorithm(digest);
+            const placeholder = new Uint8Array(keyBytes);
+            encodePasswordHash({
+                version: PASSWORD_FORMAT_VERSION,
+                algorithm: label,
+                digest,
+                salt,
+                hash: placeholder,
+                iterations,
+            });
+            const hash = await deriveKey({
+                password: passwordBytes,
+                salt,
+                algorithm: "pbkdf2",
+                keyLength: keyBytes,
+                iterations,
+                digest,
+            });
+            return encodePasswordHash({
+                version: PASSWORD_FORMAT_VERSION,
+                algorithm: label,
+                digest,
+                salt,
+                hash,
+                iterations,
             });
-            break;
         }
         default:
-            throw new TypeError(`Unsupported password algorithm: ${algorithm}.`);
+            throw keyDerivationError(`Unsupported password algorithm: ${String(algorithm)}.`, typeof algorithm === "string" ? algorithm : undefined);
     }
-    const saltB64 = toBase64Url(salt);
-    const hashB64 = toBase64Url(hash);
-    return [
-        PASSWORD_FORMAT_VERSION,
-        algorithm,
-        options?.memoryCost ?? 16384,
-        blockSize,
-        options?.parallelism ?? 1,
-        `${saltB64}.${hashB64}`,
-    ].join("$");
 }
+/**
+ * Verifies a password against an encoded hash.
+ *
+ * Returns false for any malformed, foreign or out-of-bounds hash string
+ * instead of throwing, so login paths fail closed. The hash is decoded
+ * and validated before any derivation work is done.
+ */
 export async function verifyPassword(password, hash) {
-    const parts = hash.split("$");
-    if (parts.length !== 6 || parts[0] !== "v1") {
+    if (typeof hash !== "string") {
         return false;
     }
-    const [version, algorithm, costPart, blockSizePart, parallelizationPart, payload,] = parts;
-    if (version !== "v1" || !payload) {
-        return false;
+    let decoded;
+    try {
+        decoded = decodePasswordHash(hash);
     }
-    const payloadParts = payload.split(".");
-    if (payloadParts.length !== 2) {
+    catch {
         return false;
     }
-    const [saltB64] = payloadParts;
-    if (!saltB64) {
-        return false;
+    const passwordBytes = toBytes(password);
+    let expected;
+    if (decoded.algorithm === CryptoAlgorithm.SCRYPT) {
+        expected = await deriveKey({
+            password: passwordBytes,
+            salt: decoded.salt,
+            algorithm: "scrypt",
+            keyLength: decoded.hash.byteLength,
+            memoryCost: decoded.cost,
+            blockSize: decoded.blockSize,
+            parallelism: decoded.parallelization,
+        });
     }
-    const salt = fromBase64Url(saltB64);
-    const computed = await hashPassword(password, {
-        algorithm: algorithm,
-        memoryCost: Number(costPart),
-        blockSize: Number(blockSizePart),
-        parallelism: Number(parallelizationPart),
-        salt,
-    });
-    const computedParts = computed.split("$");
-    if (computedParts.length !== 6) {
-        return false;
+    else {
+        expected = await deriveKey({
+            password: passwordBytes,
+            salt: decoded.salt,
+            algorithm: "pbkdf2",
+            keyLength: decoded.hash.byteLength,
+            iterations: decoded.iterations,
+            digest: decoded.digest,
+        });
     }
-    const expectedHash = fromBase64Url(computedParts[5].split(".")[1]);
-    const decoded = decodePasswordHash(hash);
-    return timingSafeEqual(decoded.hash, expectedHash);
+    return timingSafeEqual(decoded.hash, expected);
 }
 //# sourceMappingURL=nodeCryptoProvider.password.js.map

package/dist/node/nodeCryptoProvider/primitives/nodeCryptoProvider.encryption.d.ts

@@ -1,13 +1,4 @@
-import type { CryptoInput, EncryptedData } from "../../../cryptoProvider/index.js";
-export declare function encrypt(options: {
-    key: CryptoInput;
-    plaintext: CryptoInput;
-    associatedData?: CryptoInput;
-    nonce?: Uint8Array;
-}): Promise<EncryptedData>;
-export declare function decrypt(options: {
-    key: CryptoInput;
-    encrypted: EncryptedData;
-    associatedData?: CryptoInput;
-}): Promise<Uint8Array>;
+import type { EncryptedData, EncryptOptions, DecryptOptions } from "../../../cryptoProvider/index.js";
+export declare function encrypt(options: EncryptOptions): Promise<EncryptedData>;
+export declare function decrypt(options: DecryptOptions): Promise<Uint8Array>;
 //# sourceMappingURL=nodeCryptoProvider.encryption.d.ts.map

package/dist/node/nodeCryptoProvider/primitives/nodeCryptoProvider.encryption.js

@@ -1,35 +1,84 @@
 import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { CryptoOperation } from "@zudojs/errors";
 import { toBytes } from "../nodeCryptoProvider.helper.js";
+import { AES_GCM } from "../../../cryptoConstants/cryptoConstants.type.js";
+import { cipherError } from "../../../cryptoErrors/cryptoErrors.helper.js";
+const ALGORITHM = "aes-256-gcm";
+/**
+ * Validates the caller-controlled inputs to AES-256-GCM before they reach
+ * OpenSSL, so that the error surface is uniform and short tags / odd IVs
+ * are never accepted.
+ */
+function assertKey(key, operation) {
+    if (key.byteLength !== AES_GCM.KEY_BYTES) {
+        throw cipherError(`AES-256-GCM key must be ${AES_GCM.KEY_BYTES} bytes.`, operation, ALGORITHM);
+    }
+}
+function assertNonce(nonce, operation) {
+    if (!(nonce instanceof Uint8Array) || nonce.byteLength !== AES_GCM.IV_BYTES) {
+        throw cipherError(`AES-256-GCM nonce must be ${AES_GCM.IV_BYTES} bytes.`, operation, ALGORITHM);
+    }
+}
+function assertTag(tag) {
+    if (!(tag instanceof Uint8Array) ||
+        tag.byteLength !== AES_GCM.AUTH_TAG_BYTES) {
+        throw cipherError(`AES-256-GCM authentication tag must be ${AES_GCM.AUTH_TAG_BYTES} bytes.`, CryptoOperation.DECRYPT, ALGORITHM);
+    }
+}
 export async function encrypt(options) {
     const key = toBytes(options.key);
     const plaintext = toBytes(options.plaintext);
-    const algorithm = "aes-256-gcm";
-    const nonce = options.nonce ?? new Uint8Array(randomBytes(12));
-    const cipher = createCipheriv("aes-256-gcm", key, nonce);
-    if (options.associatedData) {
-        cipher.setAAD(toBytes(options.associatedData));
-    }
-    const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
-    const tag = cipher.getAuthTag();
-    return Object.freeze({
-        algorithm,
-        ciphertext: new Uint8Array(ciphertext),
-        nonce,
-        tag: new Uint8Array(tag),
-    });
+    const nonce = options.nonce ?? new Uint8Array(randomBytes(AES_GCM.IV_BYTES));
+    assertKey(key, CryptoOperation.ENCRYPT);
+    assertNonce(nonce, CryptoOperation.ENCRYPT);
+    try {
+        const cipher = createCipheriv(ALGORITHM, key, nonce, {
+            authTagLength: AES_GCM.AUTH_TAG_BYTES,
+        });
+        if (options.associatedData !== undefined) {
+            cipher.setAAD(toBytes(options.associatedData));
+        }
+        const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+        const tag = cipher.getAuthTag();
+        return Object.freeze({
+            algorithm: ALGORITHM,
+            ciphertext: new Uint8Array(ciphertext),
+            nonce: new Uint8Array(nonce),
+            tag: new Uint8Array(tag),
+        });
+    }
+    catch (error) {
+        throw cipherError("Encryption failed.", CryptoOperation.ENCRYPT, ALGORITHM, error);
+    }
 }
 export async function decrypt(options) {
     const key = toBytes(options.key);
-    const { ciphertext, nonce, tag } = options.encrypted;
-    const decipher = createDecipheriv(options.encrypted.algorithm, key, nonce);
-    if (options.associatedData) {
-        decipher.setAAD(toBytes(options.associatedData));
-    }
-    decipher.setAuthTag(tag);
-    const decrypted = Buffer.concat([
-        decipher.update(ciphertext),
-        decipher.final(),
-    ]);
-    return new Uint8Array(decrypted);
+    const { ciphertext, nonce, tag, algorithm } = options.encrypted;
+    if (algorithm !== ALGORITHM) {
+        throw cipherError(`Unsupported encryption algorithm: ${String(algorithm)}.`, CryptoOperation.DECRYPT, typeof algorithm === "string" ? algorithm : undefined);
+    }
+    assertKey(key, CryptoOperation.DECRYPT);
+    assertNonce(nonce, CryptoOperation.DECRYPT);
+    assertTag(tag);
+    if (!(ciphertext instanceof Uint8Array)) {
+        throw cipherError("Ciphertext must be a Uint8Array.", CryptoOperation.DECRYPT, ALGORITHM);
+    }
+    try {
+        const decipher = createDecipheriv(ALGORITHM, key, nonce, {
+            authTagLength: AES_GCM.AUTH_TAG_BYTES,
+        });
+        if (options.associatedData !== undefined) {
+            decipher.setAAD(toBytes(options.associatedData));
+        }
+        decipher.setAuthTag(tag);
+        const decrypted = Buffer.concat([
+            decipher.update(ciphertext),
+            decipher.final(),
+        ]);
+        return new Uint8Array(decrypted);
+    }
+    catch (error) {
+        throw cipherError("Decryption failed.", CryptoOperation.DECRYPT, ALGORITHM, error);
+    }
 }
 //# sourceMappingURL=nodeCryptoProvider.encryption.js.map