@gjsify/crypto 0.3.13 → 0.3.15

package/lib/esm/mgf1.js

@@ -1,27 +1,33 @@
-import { Hash } from "./hash.js";
 import { hashSize } from "./crypto-utils.js";
+import { Hash } from "./hash.js";
+
+//#region src/mgf1.ts
+/**
+* MGF1 mask generation function.
+* Produces a mask of `length` bytes from `seed` using `hashAlgo`.
+*/
 function mgf1(hashAlgo, seed, length) {
-  const hashLen = hashSize(hashAlgo);
-  const mask = new Uint8Array(length);
-  let offset = 0;
-  let counter = 0;
-  while (offset < length) {
-    const C = new Uint8Array(4);
-    C[0] = counter >>> 24 & 255;
-    C[1] = counter >>> 16 & 255;
-    C[2] = counter >>> 8 & 255;
-    C[3] = counter & 255;
-    const hash = new Hash(hashAlgo);
-    hash.update(seed);
-    hash.update(C);
-    const digest = new Uint8Array(hash.digest());
-    const toCopy = Math.min(digest.length, length - offset);
-    mask.set(digest.slice(0, toCopy), offset);
-    offset += toCopy;
-    counter++;
-  }
-  return mask;
+	const hashLen = hashSize(hashAlgo);
+	const mask = new Uint8Array(length);
+	let offset = 0;
+	let counter = 0;
+	while (offset < length) {
+		const C = new Uint8Array(4);
+		C[0] = counter >>> 24 & 255;
+		C[1] = counter >>> 16 & 255;
+		C[2] = counter >>> 8 & 255;
+		C[3] = counter & 255;
+		const hash = new Hash(hashAlgo);
+		hash.update(seed);
+		hash.update(C);
+		const digest = new Uint8Array(hash.digest());
+		const toCopy = Math.min(digest.length, length - offset);
+		mask.set(digest.slice(0, toCopy), offset);
+		offset += toCopy;
+		counter++;
+	}
+	return mask;
 }
-export {
-  mgf1
-};
+
+//#endregion
+export { mgf1 };

package/lib/esm/pbkdf2.js

@@ -1,68 +1,75 @@
-import { Buffer } from "node:buffer";
+import { DIGEST_SIZES, SUPPORTED_ALGORITHMS, normalizeAlgorithm, toBuffer } from "./crypto-utils.js";
 import { Hmac } from "./hmac.js";
-import { normalizeAlgorithm, DIGEST_SIZES, SUPPORTED_ALGORITHMS, toBuffer } from "./crypto-utils.js";
+import { Buffer } from "node:buffer";
+
+//#region src/pbkdf2.ts
 function hmacDigest(algo, key, data) {
-  const hmac = new Hmac(algo, key);
-  hmac.update(data);
-  return hmac.digest();
+	const hmac = new Hmac(algo, key);
+	hmac.update(data);
+	return hmac.digest();
 }
 function validateParameters(iterations, keylen) {
-  if (typeof iterations !== "number" || iterations < 0 || !Number.isFinite(iterations)) {
-    throw new TypeError("iterations must be a positive number");
-  }
-  if (iterations === 0) {
-    throw new TypeError("iterations must be a positive number");
-  }
-  if (typeof keylen !== "number" || keylen < 0 || !Number.isFinite(keylen) || keylen > 2147483647) {
-    throw new TypeError("keylen must be a positive number");
-  }
+	if (typeof iterations !== "number" || iterations < 0 || !Number.isFinite(iterations)) {
+		throw new TypeError("iterations must be a positive number");
+	}
+	if (iterations === 0) {
+		throw new TypeError("iterations must be a positive number");
+	}
+	if (typeof keylen !== "number" || keylen < 0 || !Number.isFinite(keylen) || keylen > 2147483647) {
+		throw new TypeError("keylen must be a positive number");
+	}
 }
+/**
+* Synchronous PBKDF2 key derivation.
+*/
 function pbkdf2Sync(password, salt, iterations, keylen, digest) {
-  validateParameters(iterations, keylen);
-  const passwordBuf = toBuffer(password);
-  const saltBuf = toBuffer(salt);
-  const algo = normalizeAlgorithm(digest || "sha1");
-  const hashLen = DIGEST_SIZES[algo];
-  if (!SUPPORTED_ALGORITHMS.has(algo) || hashLen === void 0) {
-    throw new TypeError(`Unknown message digest: ${digest || "sha1"}`);
-  }
-  if (keylen === 0) {
-    return Buffer.alloc(0);
-  }
-  const numBlocks = Math.ceil(keylen / hashLen);
-  const dk = Buffer.allocUnsafe(numBlocks * hashLen);
-  for (let blockIndex = 1; blockIndex <= numBlocks; blockIndex++) {
-    const block = Buffer.allocUnsafe(saltBuf.length + 4);
-    saltBuf.copy(block, 0);
-    block.writeUInt32BE(blockIndex, saltBuf.length);
-    let u = hmacDigest(algo, passwordBuf, block);
-    let t = Buffer.from(u);
-    for (let iter = 1; iter < iterations; iter++) {
-      u = hmacDigest(algo, passwordBuf, u);
-      for (let k = 0; k < hashLen; k++) {
-        t[k] ^= u[k];
-      }
-    }
-    t.copy(dk, (blockIndex - 1) * hashLen);
-  }
-  return Buffer.from(dk.buffer, dk.byteOffset, keylen);
+	validateParameters(iterations, keylen);
+	const passwordBuf = toBuffer(password);
+	const saltBuf = toBuffer(salt);
+	const algo = normalizeAlgorithm(digest || "sha1");
+	const hashLen = DIGEST_SIZES[algo];
+	if (!SUPPORTED_ALGORITHMS.has(algo) || hashLen === undefined) {
+		throw new TypeError(`Unknown message digest: ${digest || "sha1"}`);
+	}
+	if (keylen === 0) {
+		return Buffer.alloc(0);
+	}
+	const numBlocks = Math.ceil(keylen / hashLen);
+	const dk = Buffer.allocUnsafe(numBlocks * hashLen);
+	for (let blockIndex = 1; blockIndex <= numBlocks; blockIndex++) {
+		const block = Buffer.allocUnsafe(saltBuf.length + 4);
+		saltBuf.copy(block, 0);
+		block.writeUInt32BE(blockIndex, saltBuf.length);
+		let u = hmacDigest(algo, passwordBuf, block);
+		let t = Buffer.from(u);
+		for (let iter = 1; iter < iterations; iter++) {
+			u = hmacDigest(algo, passwordBuf, u);
+			for (let k = 0; k < hashLen; k++) {
+				t[k] ^= u[k];
+			}
+		}
+		t.copy(dk, (blockIndex - 1) * hashLen);
+	}
+	return Buffer.from(dk.buffer, dk.byteOffset, keylen);
 }
+/**
+* Asynchronous PBKDF2 key derivation.
+*/
 function pbkdf2(password, salt, iterations, keylen, digest, callback) {
-  try {
-    validateParameters(iterations, keylen);
-  } catch (err) {
-    throw err;
-  }
-  setTimeout(() => {
-    try {
-      const result = pbkdf2Sync(password, salt, iterations, keylen, digest);
-      callback(null, result);
-    } catch (err) {
-      callback(err instanceof Error ? err : new Error(String(err)));
-    }
-  }, 0);
+	try {
+		validateParameters(iterations, keylen);
+	} catch (err) {
+		throw err;
+	}
+	setTimeout(() => {
+		try {
+			const result = pbkdf2Sync(password, salt, iterations, keylen, digest);
+			callback(null, result);
+		} catch (err) {
+			callback(err instanceof Error ? err : new Error(String(err)));
+		}
+	}, 0);
 }
-export {
-  pbkdf2,
-  pbkdf2Sync
-};
+
+//#endregion
+export { pbkdf2, pbkdf2Sync };

package/lib/esm/public-encrypt.js

@@ -1,175 +1,222 @@
-import { Buffer } from "node:buffer";
-import { randomBytes } from "./random.js";
 import { parsePemKey, rsaKeySize } from "./asn1.js";
-import { modPow, bigIntToBytes, bytesToBigInt } from "./bigint-math.js";
+import { bigIntToBytes, bytesToBigInt, modPow } from "./bigint-math.js";
+import { randomBytes } from "./random.js";
+import { Buffer } from "node:buffer";
+
+//#region src/public-encrypt.ts
 function extractPem(key) {
-  if (typeof key === "string") {
-    return key;
-  }
-  if (Buffer.isBuffer(key) || key instanceof Uint8Array) {
-    return Buffer.from(key).toString("utf8");
-  }
-  if (key && typeof key === "object" && "key" in key) {
-    const k = key.key;
-    if (typeof k === "string") return k;
-    if (Buffer.isBuffer(k) || k instanceof Uint8Array) return Buffer.from(k).toString("utf8");
-  }
-  throw new TypeError("Invalid key argument");
+	if (typeof key === "string") {
+		return key;
+	}
+	if (Buffer.isBuffer(key) || key instanceof Uint8Array) {
+		return Buffer.from(key).toString("utf8");
+	}
+	if (key && typeof key === "object" && "key" in key) {
+		const k = key.key;
+		if (typeof k === "string") return k;
+		if (Buffer.isBuffer(k) || k instanceof Uint8Array) return Buffer.from(k).toString("utf8");
+	}
+	throw new TypeError("Invalid key argument");
 }
+/**
+* Apply PKCS#1 v1.5 Type 2 padding (for encryption).
+* Format: 0x00 0x02 [random non-zero bytes] 0x00 [data]
+* The padding string (PS) must be at least 8 bytes.
+*/
 function pkcs1v15Type2Pad(data, keyLen) {
-  const maxDataLen = keyLen - 11;
-  if (data.length > maxDataLen) {
-    throw new Error(`Data too long for key size. Max ${maxDataLen} bytes, got ${data.length}`);
-  }
-  const padLen = keyLen - data.length - 3;
-  const em = new Uint8Array(keyLen);
-  em[0] = 0;
-  em[1] = 2;
-  const padding = randomBytes(padLen);
-  for (let i = 0; i < padLen; i++) {
-    while (padding[i] === 0) {
-      const replacement = randomBytes(1);
-      padding[i] = replacement[0];
-    }
-    em[2 + i] = padding[i];
-  }
-  em[2 + padLen] = 0;
-  em.set(data, 3 + padLen);
-  return em;
+	const maxDataLen = keyLen - 11;
+	if (data.length > maxDataLen) {
+		throw new Error(`Data too long for key size. Max ${maxDataLen} bytes, got ${data.length}`);
+	}
+	const padLen = keyLen - data.length - 3;
+	const em = new Uint8Array(keyLen);
+	em[0] = 0;
+	em[1] = 2;
+	const padding = randomBytes(padLen);
+	for (let i = 0; i < padLen; i++) {
+		while (padding[i] === 0) {
+			const replacement = randomBytes(1);
+			padding[i] = replacement[0];
+		}
+		em[2 + i] = padding[i];
+	}
+	em[2 + padLen] = 0;
+	em.set(data, 3 + padLen);
+	return em;
 }
+/**
+* Apply PKCS#1 v1.5 Type 1 padding (for private-key encryption / signature).
+* Format: 0x00 0x01 [0xFF bytes] 0x00 [data]
+*/
 function pkcs1v15Type1Pad(data, keyLen) {
-  const maxDataLen = keyLen - 11;
-  if (data.length > maxDataLen) {
-    throw new Error(`Data too long for key size. Max ${maxDataLen} bytes, got ${data.length}`);
-  }
-  const padLen = keyLen - data.length - 3;
-  const em = new Uint8Array(keyLen);
-  em[0] = 0;
-  em[1] = 1;
-  for (let i = 2; i < 2 + padLen; i++) {
-    em[i] = 255;
-  }
-  em[2 + padLen] = 0;
-  em.set(data, 3 + padLen);
-  return em;
+	const maxDataLen = keyLen - 11;
+	if (data.length > maxDataLen) {
+		throw new Error(`Data too long for key size. Max ${maxDataLen} bytes, got ${data.length}`);
+	}
+	const padLen = keyLen - data.length - 3;
+	const em = new Uint8Array(keyLen);
+	em[0] = 0;
+	em[1] = 1;
+	for (let i = 2; i < 2 + padLen; i++) {
+		em[i] = 255;
+	}
+	em[2 + padLen] = 0;
+	em.set(data, 3 + padLen);
+	return em;
 }
+/**
+* Remove PKCS#1 v1.5 Type 2 padding (after decryption with private key).
+* Expects: 0x00 0x02 [random non-zero bytes] 0x00 [data]
+*/
 function pkcs1v15Type2Unpad(em) {
-  if (em.length < 11) {
-    throw new Error("Decryption error: message too short");
-  }
-  if (em[0] !== 0 || em[1] !== 2) {
-    throw new Error("Decryption error: invalid padding");
-  }
-  let sepIdx = 2;
-  while (sepIdx < em.length && em[sepIdx] !== 0) {
-    sepIdx++;
-  }
-  if (sepIdx >= em.length || sepIdx < 10) {
-    throw new Error("Decryption error: invalid padding");
-  }
-  return em.slice(sepIdx + 1);
+	if (em.length < 11) {
+		throw new Error("Decryption error: message too short");
+	}
+	if (em[0] !== 0 || em[1] !== 2) {
+		throw new Error("Decryption error: invalid padding");
+	}
+	let sepIdx = 2;
+	while (sepIdx < em.length && em[sepIdx] !== 0) {
+		sepIdx++;
+	}
+	if (sepIdx >= em.length || sepIdx < 10) {
+		throw new Error("Decryption error: invalid padding");
+	}
+	return em.slice(sepIdx + 1);
 }
+/**
+* Remove PKCS#1 v1.5 Type 1 padding (after decryption with public key).
+* Expects: 0x00 0x01 [0xFF bytes] 0x00 [data]
+*/
 function pkcs1v15Type1Unpad(em) {
-  if (em.length < 11) {
-    throw new Error("Decryption error: message too short");
-  }
-  if (em[0] !== 0 || em[1] !== 1) {
-    throw new Error("Decryption error: invalid padding");
-  }
-  let sepIdx = 2;
-  while (sepIdx < em.length && em[sepIdx] === 255) {
-    sepIdx++;
-  }
-  if (sepIdx >= em.length || em[sepIdx] !== 0 || sepIdx < 10) {
-    throw new Error("Decryption error: invalid padding");
-  }
-  return em.slice(sepIdx + 1);
+	if (em.length < 11) {
+		throw new Error("Decryption error: message too short");
+	}
+	if (em[0] !== 0 || em[1] !== 1) {
+		throw new Error("Decryption error: invalid padding");
+	}
+	let sepIdx = 2;
+	while (sepIdx < em.length && em[sepIdx] === 255) {
+		sepIdx++;
+	}
+	if (sepIdx >= em.length || em[sepIdx] !== 0 || sepIdx < 10) {
+		throw new Error("Decryption error: invalid padding");
+	}
+	return em.slice(sepIdx + 1);
 }
+/**
+* Encrypt data using an RSA public key with PKCS#1 v1.5 Type 2 padding.
+*
+* @param key - PEM-encoded RSA public key (or private key, from which public components are extracted)
+* @param buffer - Data to encrypt (must be <= keyLen - 11 bytes)
+* @returns Encrypted data as a Buffer
+*/
 function publicEncrypt(key, buffer) {
-  const pem = extractPem(key);
-  const parsed = parsePemKey(pem);
-  let n;
-  let e;
-  if (parsed.type === "rsa-public") {
-    n = parsed.components.n;
-    e = parsed.components.e;
-  } else if (parsed.type === "rsa-private") {
-    n = parsed.components.n;
-    e = parsed.components.e;
-  } else {
-    throw new Error("Key must be an RSA public or private key");
-  }
-  const keyLen = rsaKeySize(n);
-  const data = buffer instanceof Uint8Array ? buffer : Buffer.from(buffer);
-  const em = pkcs1v15Type2Pad(data, keyLen);
-  const m = bytesToBigInt(em);
-  const c = modPow(m, e, n);
-  return Buffer.from(bigIntToBytes(c, keyLen));
+	const pem = extractPem(key);
+	const parsed = parsePemKey(pem);
+	let n;
+	let e;
+	if (parsed.type === "rsa-public") {
+		n = parsed.components.n;
+		e = parsed.components.e;
+	} else if (parsed.type === "rsa-private") {
+		n = parsed.components.n;
+		e = parsed.components.e;
+	} else {
+		throw new Error("Key must be an RSA public or private key");
+	}
+	const keyLen = rsaKeySize(n);
+	const data = buffer instanceof Uint8Array ? buffer : Buffer.from(buffer);
+	const em = pkcs1v15Type2Pad(data, keyLen);
+	const m = bytesToBigInt(em);
+	const c = modPow(m, e, n);
+	return Buffer.from(bigIntToBytes(c, keyLen));
 }
+/**
+* Decrypt data using an RSA private key (reverses publicEncrypt).
+*
+* @param key - PEM-encoded RSA private key
+* @param buffer - Encrypted data
+* @returns Decrypted data as a Buffer
+*/
 function privateDecrypt(key, buffer) {
-  const pem = extractPem(key);
-  const parsed = parsePemKey(pem);
-  if (parsed.type !== "rsa-private") {
-    throw new Error("Key must be an RSA private key");
-  }
-  const { n, d } = parsed.components;
-  const keyLen = rsaKeySize(n);
-  const data = buffer instanceof Uint8Array ? buffer : Buffer.from(buffer);
-  if (data.length !== keyLen) {
-    throw new Error(`Data length (${data.length}) does not match key length (${keyLen})`);
-  }
-  const c = bytesToBigInt(data);
-  if (c >= n) {
-    throw new Error("Decryption error: cipher value out of range");
-  }
-  const m = modPow(c, d, n);
-  const em = bigIntToBytes(m, keyLen);
-  return Buffer.from(pkcs1v15Type2Unpad(em));
+	const pem = extractPem(key);
+	const parsed = parsePemKey(pem);
+	if (parsed.type !== "rsa-private") {
+		throw new Error("Key must be an RSA private key");
+	}
+	const { n, d } = parsed.components;
+	const keyLen = rsaKeySize(n);
+	const data = buffer instanceof Uint8Array ? buffer : Buffer.from(buffer);
+	if (data.length !== keyLen) {
+		throw new Error(`Data length (${data.length}) does not match key length (${keyLen})`);
+	}
+	const c = bytesToBigInt(data);
+	if (c >= n) {
+		throw new Error("Decryption error: cipher value out of range");
+	}
+	const m = modPow(c, d, n);
+	const em = bigIntToBytes(m, keyLen);
+	return Buffer.from(pkcs1v15Type2Unpad(em));
 }
+/**
+* Encrypt data using an RSA private key with PKCS#1 v1.5 Type 1 padding.
+* This is the raw RSA private-key operation used for compatibility with
+* signature-like use cases.
+*
+* @param key - PEM-encoded RSA private key
+* @param buffer - Data to encrypt
+* @returns Encrypted data as a Buffer
+*/
 function privateEncrypt(key, buffer) {
-  const pem = extractPem(key);
-  const parsed = parsePemKey(pem);
-  if (parsed.type !== "rsa-private") {
-    throw new Error("Key must be an RSA private key");
-  }
-  const { n, d } = parsed.components;
-  const keyLen = rsaKeySize(n);
-  const data = buffer instanceof Uint8Array ? buffer : Buffer.from(buffer);
-  const em = pkcs1v15Type1Pad(data, keyLen);
-  const m = bytesToBigInt(em);
-  const c = modPow(m, d, n);
-  return Buffer.from(bigIntToBytes(c, keyLen));
+	const pem = extractPem(key);
+	const parsed = parsePemKey(pem);
+	if (parsed.type !== "rsa-private") {
+		throw new Error("Key must be an RSA private key");
+	}
+	const { n, d } = parsed.components;
+	const keyLen = rsaKeySize(n);
+	const data = buffer instanceof Uint8Array ? buffer : Buffer.from(buffer);
+	const em = pkcs1v15Type1Pad(data, keyLen);
+	const m = bytesToBigInt(em);
+	const c = modPow(m, d, n);
+	return Buffer.from(bigIntToBytes(c, keyLen));
 }
+/**
+* Decrypt data using an RSA public key (reverses privateEncrypt).
+* Removes PKCS#1 v1.5 Type 1 padding.
+*
+* @param key - PEM-encoded RSA public key (or private key for public components)
+* @param buffer - Encrypted data
+* @returns Decrypted data as a Buffer
+*/
 function publicDecrypt(key, buffer) {
-  const pem = extractPem(key);
-  const parsed = parsePemKey(pem);
-  let n;
-  let e;
-  if (parsed.type === "rsa-public") {
-    n = parsed.components.n;
-    e = parsed.components.e;
-  } else if (parsed.type === "rsa-private") {
-    n = parsed.components.n;
-    e = parsed.components.e;
-  } else {
-    throw new Error("Key must be an RSA public or private key");
-  }
-  const keyLen = rsaKeySize(n);
-  const data = buffer instanceof Uint8Array ? buffer : Buffer.from(buffer);
-  if (data.length !== keyLen) {
-    throw new Error(`Data length (${data.length}) does not match key length (${keyLen})`);
-  }
-  const c = bytesToBigInt(data);
-  if (c >= n) {
-    throw new Error("Decryption error: cipher value out of range");
-  }
-  const m = modPow(c, e, n);
-  const em = bigIntToBytes(m, keyLen);
-  return Buffer.from(pkcs1v15Type1Unpad(em));
+	const pem = extractPem(key);
+	const parsed = parsePemKey(pem);
+	let n;
+	let e;
+	if (parsed.type === "rsa-public") {
+		n = parsed.components.n;
+		e = parsed.components.e;
+	} else if (parsed.type === "rsa-private") {
+		n = parsed.components.n;
+		e = parsed.components.e;
+	} else {
+		throw new Error("Key must be an RSA public or private key");
+	}
+	const keyLen = rsaKeySize(n);
+	const data = buffer instanceof Uint8Array ? buffer : Buffer.from(buffer);
+	if (data.length !== keyLen) {
+		throw new Error(`Data length (${data.length}) does not match key length (${keyLen})`);
+	}
+	const c = bytesToBigInt(data);
+	if (c >= n) {
+		throw new Error("Decryption error: cipher value out of range");
+	}
+	const m = modPow(c, e, n);
+	const em = bigIntToBytes(m, keyLen);
+	return Buffer.from(pkcs1v15Type1Unpad(em));
 }
-export {
-  privateDecrypt,
-  privateEncrypt,
-  publicDecrypt,
-  publicEncrypt
-};
+
+//#endregion
+export { privateDecrypt, privateEncrypt, publicDecrypt, publicEncrypt };