@zudojs/crypto 0.0.1 → 1.0.0

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

@@ -1,45 +1,104 @@
-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";
+/** 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;
+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) {
+        throw keyDerivationError(`keyLength must be an integer of at least ${PROVIDER_MIN_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) {
+                throw keyDerivationError(`PBKDF2 iterations must be an integer of at least ${PROVIDER_MIN_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 & (N - 1)) !== 0) {
+                throw keyDerivationError("scrypt cost must be a power of two greater than or equal to 2.", "scrypt");
+            }
+            if (!Number.isInteger(r) || r <= 0) {
+                throw keyDerivationError("scrypt blockSize must be a positive integer.", "scrypt");
+            }
+            if (!Number.isInteger(p) || p <= 0) {
+                throw keyDerivationError("scrypt parallelism must be a positive integer.", "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

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

@@ -1,15 +1,20 @@
 import { createHash, createHmac } from "node:crypto";
 import { toBytes, nodeHashAlgorithm } from "../nodeCryptoProvider.helper.js";
 export async function hash(algorithm, data) {
+    const digestName = nodeHashAlgorithm(algorithm);
     const normalized = toBytes(data);
-    const hasher = createHash(nodeHashAlgorithm(algorithm));
+    const hasher = createHash(digestName);
     hasher.update(normalized);
     return new Uint8Array(hasher.digest());
 }
 export async function hmac(algorithm, key, data) {
+    const digestName = nodeHashAlgorithm(algorithm);
     const normalizedKey = toBytes(key);
+    if (normalizedKey.byteLength === 0) {
+        throw new TypeError("HMAC key must not be empty.");
+    }
     const normalizedData = toBytes(data);
-    const h = createHmac(nodeHashAlgorithm(algorithm), normalizedKey);
+    const h = createHmac(digestName, normalizedKey);
     h.update(normalizedData);
     return new Uint8Array(h.digest());
 }

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

@@ -1,4 +1,10 @@
 export declare function randomBytesImpl(length: number): Promise<Uint8Array>;
+/**
+ * Returns a uniformly distributed integer in `[min, max)`.
+ *
+ * Delegates to `node:crypto.randomInt`, which is unbiased for ranges up
+ * to 2^48. A range of exactly one value returns `min`.
+ */
 export declare function randomIntImpl(min: number, max: number): Promise<number>;
 export declare function randomUUIDImpl(): Promise<string>;
 //# sourceMappingURL=nodeCryptoProvider.random.d.ts.map

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

@@ -1,39 +1,39 @@
-import { randomBytes } from "node:crypto";
+import { randomBytes, randomInt } from "node:crypto";
+/** Largest range accepted by `node:crypto.randomInt`. */
+const MAX_RANGE = 2 ** 48;
 export async function randomBytesImpl(length) {
     if (!Number.isInteger(length) || length <= 0) {
         throw new TypeError("randomBytes length must be a positive integer.");
     }
     return new Uint8Array(randomBytes(length));
 }
+/**
+ * Returns a uniformly distributed integer in `[min, max)`.
+ *
+ * Delegates to `node:crypto.randomInt`, which is unbiased for ranges up
+ * to 2^48. A range of exactly one value returns `min`.
+ */
 export async function randomIntImpl(min, max) {
-    if (!Number.isInteger(min) || !Number.isInteger(max)) {
-        throw new TypeError("randomInt bounds must be integers.");
+    if (!Number.isSafeInteger(min) || !Number.isSafeInteger(max)) {
+        throw new TypeError("randomInt bounds must be safe integers.");
     }
     if (max <= min) {
         throw new RangeError("max must be greater than min.");
     }
     const range = max - min;
-    const bytesNeeded = Math.ceil(Math.log2(range) / 8);
-    const limit = Math.floor(256 ** bytesNeeded / range) * range;
-    while (true) {
-        const bytes = await randomBytesImpl(bytesNeeded);
-        let value = 0;
-        for (let i = 0; i < bytesNeeded; i += 1) {
-            value = (value << 8) | bytes[i];
-        }
-        value = value >>> 0;
-        if (value < limit) {
-            return min + (value % range);
-        }
+    if (range > MAX_RANGE) {
+        throw new RangeError(`randomInt range must not exceed 2^48.`);
     }
+    if (range === 1) {
+        return min;
+    }
+    return randomInt(min, max);
 }
 export async function randomUUIDImpl() {
     const bytes = await randomBytesImpl(16);
     bytes[6] = (bytes[6] & 0x0f) | 0x40;
     bytes[8] = (bytes[8] & 0x3f) | 0x80;
-    const hex = Array.from(bytes)
-        .map((b) => b.toString(16).padStart(2, "0"))
-        .join("");
+    const hex = Buffer.from(bytes).toString("hex");
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
 //# sourceMappingURL=nodeCryptoProvider.random.js.map

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

@@ -1,13 +1,11 @@
-import type { SignatureAlgorithm, CryptoInput } from "../../../cryptoProvider/index.js";
-export declare function sign(options: {
-    key: CryptoInput;
-    data: CryptoInput;
-    algorithm?: SignatureAlgorithm;
-}): Promise<Uint8Array>;
-export declare function verify(options: {
-    key: CryptoInput;
-    data: CryptoInput;
-    signature: Uint8Array;
-    algorithm?: SignatureAlgorithm;
-}): Promise<boolean>;
+import type { SignOptions, VerifyOptions } from "../../../cryptoProvider/index.js";
+export declare function sign(options: SignOptions): Promise<Uint8Array>;
+/**
+ * Verifies a signature.
+ *
+ * Returns false for a malformed key, malformed signature or mismatching
+ * data. Throws only for programmer errors (unsupported algorithm, key
+ * type that cannot be used with the algorithm).
+ */
+export declare function verify(options: VerifyOptions): Promise<boolean>;
 //# sourceMappingURL=nodeCryptoProvider.signing.d.ts.map