@gjsify/crypto 0.3.13 → 0.3.15

package/lib/esm/sign.js

@@ -1,248 +1,278 @@
-import { Buffer } from "node:buffer";
-import { Hash } from "./hash.js";
 import { parsePemKey, rsaKeySize } from "./asn1.js";
-import { modPow, bigIntToBytes, bytesToBigInt } from "./bigint-math.js";
+import { bigIntToBytes, bytesToBigInt, modPow } from "./bigint-math.js";
+import { Hash } from "./hash.js";
+import { Buffer } from "node:buffer";
+
+//#region src/sign.ts
+/**
+* DigestInfo DER prefix bytes for each supported hash algorithm.
+* These encode: SEQUENCE { SEQUENCE { OID hashAlg, NULL }, OCTET STRING hashValue }
+* excluding the actual hash value at the end.
+*/
 const DIGEST_INFO_PREFIX = {
-  sha1: new Uint8Array([
-    48,
-    33,
-    48,
-    9,
-    6,
-    5,
-    43,
-    14,
-    3,
-    2,
-    26,
-    5,
-    0,
-    4,
-    20
-  ]),
-  sha256: new Uint8Array([
-    48,
-    49,
-    48,
-    13,
-    6,
-    9,
-    96,
-    134,
-    72,
-    1,
-    101,
-    3,
-    4,
-    2,
-    1,
-    5,
-    0,
-    4,
-    32
-  ]),
-  sha512: new Uint8Array([
-    48,
-    81,
-    48,
-    13,
-    6,
-    9,
-    96,
-    134,
-    72,
-    1,
-    101,
-    3,
-    4,
-    2,
-    3,
-    5,
-    0,
-    4,
-    64
-  ])
+	sha1: new Uint8Array([
+		48,
+		33,
+		48,
+		9,
+		6,
+		5,
+		43,
+		14,
+		3,
+		2,
+		26,
+		5,
+		0,
+		4,
+		20
+	]),
+	sha256: new Uint8Array([
+		48,
+		49,
+		48,
+		13,
+		6,
+		9,
+		96,
+		134,
+		72,
+		1,
+		101,
+		3,
+		4,
+		2,
+		1,
+		5,
+		0,
+		4,
+		32
+	]),
+	sha512: new Uint8Array([
+		48,
+		81,
+		48,
+		13,
+		6,
+		9,
+		96,
+		134,
+		72,
+		1,
+		101,
+		3,
+		4,
+		2,
+		3,
+		5,
+		0,
+		4,
+		64
+	])
 };
+/**
+* Normalize algorithm strings like "RSA-SHA256", "SHA256", "sha256" to
+* the canonical hash name used internally (e.g. "sha256").
+*/
 function normalizeSignAlgorithm(algorithm) {
-  let alg = algorithm.toLowerCase().replace(/-/g, "");
-  if (alg.startsWith("rsa")) {
-    alg = alg.slice(3);
-  }
-  if (!DIGEST_INFO_PREFIX[alg]) {
-    throw new Error(`Unsupported algorithm: ${algorithm}. Supported: RSA-SHA1, RSA-SHA256, RSA-SHA512`);
-  }
-  return alg;
+	let alg = algorithm.toLowerCase().replace(/-/g, "");
+	if (alg.startsWith("rsa")) {
+		alg = alg.slice(3);
+	}
+	if (!DIGEST_INFO_PREFIX[alg]) {
+		throw new Error(`Unsupported algorithm: ${algorithm}. Supported: RSA-SHA1, RSA-SHA256, RSA-SHA512`);
+	}
+	return alg;
 }
 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");
-}
-class Sign {
-  _algorithm;
-  _hash;
-  _finalized = false;
-  constructor(algorithm) {
-    this._algorithm = normalizeSignAlgorithm(algorithm);
-    this._hash = new Hash(this._algorithm);
-  }
-  /**
-   * Update the Sign object with the given data.
-   */
-  update(data, inputEncoding) {
-    if (this._finalized) {
-      throw new Error("Sign was already finalized");
-    }
-    this._hash.update(data, inputEncoding);
-    return this;
-  }
-  /**
-   * Compute the signature using the private key.
-   * Returns the signature as a Buffer (or string if outputEncoding is given).
-   */
-  sign(privateKey, outputEncoding) {
-    if (this._finalized) {
-      throw new Error("Sign was already finalized");
-    }
-    this._finalized = true;
-    const digest = this._hash.digest();
-    const pem = extractPem(privateKey);
-    const parsed = parsePemKey(pem);
-    if (parsed.type !== "rsa-private") {
-      throw new Error("privateKey must be an RSA private key");
-    }
-    const { n, e, d } = parsed.components;
-    const keyLen = rsaKeySize(n);
-    const prefix = DIGEST_INFO_PREFIX[this._algorithm];
-    const digestInfo = new Uint8Array(prefix.length + digest.length);
-    digestInfo.set(prefix, 0);
-    digestInfo.set(digest, prefix.length);
-    const padLen = keyLen - digestInfo.length - 3;
-    if (padLen < 8) {
-      throw new Error("Key is too short for the specified hash algorithm");
-    }
-    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(digestInfo, 3 + padLen);
-    const m = bytesToBigInt(em);
-    const s = modPow(m, d, n);
-    const sigBytes = bigIntToBytes(s, keyLen);
-    const sigBuf = Buffer.from(sigBytes);
-    if (outputEncoding) {
-      return sigBuf.toString(outputEncoding);
-    }
-    return sigBuf;
-  }
-}
-class Verify {
-  _algorithm;
-  _hash;
-  _finalized = false;
-  constructor(algorithm) {
-    this._algorithm = normalizeSignAlgorithm(algorithm);
-    this._hash = new Hash(this._algorithm);
-  }
-  /**
-   * Update the Verify object with the given data.
-   */
-  update(data, inputEncoding) {
-    if (this._finalized) {
-      throw new Error("Verify was already finalized");
-    }
-    this._hash.update(data, inputEncoding);
-    return this;
-  }
-  /**
-   * Verify the signature against the public key.
-   * Returns true if the signature is valid, false otherwise.
-   */
-  verify(publicKey, signature, signatureEncoding) {
-    if (this._finalized) {
-      throw new Error("Verify was already finalized");
-    }
-    this._finalized = true;
-    const digest = this._hash.digest();
-    const pem = extractPem(publicKey);
-    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("publicKey must be an RSA public or private key");
-    }
-    const keyLen = rsaKeySize(n);
-    let sigBytes;
-    if (typeof signature === "string") {
-      sigBytes = Buffer.from(signature, signatureEncoding || "base64");
-    } else {
-      sigBytes = signature instanceof Uint8Array ? signature : Buffer.from(signature);
-    }
-    if (sigBytes.length !== keyLen) {
-      return false;
-    }
-    const s = bytesToBigInt(sigBytes);
-    if (s >= n) {
-      return false;
-    }
-    const m = modPow(s, e, n);
-    const em = bigIntToBytes(m, keyLen);
-    if (em[0] !== 0 || em[1] !== 1) {
-      return false;
-    }
-    let sepIdx = 2;
-    while (sepIdx < em.length && em[sepIdx] === 255) {
-      sepIdx++;
-    }
-    if (sepIdx >= em.length || em[sepIdx] !== 0) {
-      return false;
-    }
-    if (sepIdx - 2 < 8) {
-      return false;
-    }
-    sepIdx++;
-    const recoveredDigestInfo = em.slice(sepIdx);
-    const prefix = DIGEST_INFO_PREFIX[this._algorithm];
-    const expectedDigestInfo = new Uint8Array(prefix.length + digest.length);
-    expectedDigestInfo.set(prefix, 0);
-    expectedDigestInfo.set(digest, prefix.length);
-    if (recoveredDigestInfo.length !== expectedDigestInfo.length) {
-      return false;
-    }
-    let diff = 0;
-    for (let i = 0; i < recoveredDigestInfo.length; i++) {
-      diff |= recoveredDigestInfo[i] ^ expectedDigestInfo[i];
-    }
-    return diff === 0;
-  }
+	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");
 }
+/**
+* The Sign class generates RSA PKCS#1 v1.5 signatures.
+*
+* Usage:
+*   const sign = createSign('RSA-SHA256');
+*   sign.update('data');
+*   const signature = sign.sign(privateKey);
+*/
+var Sign = class {
+	_algorithm;
+	_hash;
+	_finalized = false;
+	constructor(algorithm) {
+		this._algorithm = normalizeSignAlgorithm(algorithm);
+		this._hash = new Hash(this._algorithm);
+	}
+	/**
+	* Update the Sign object with the given data.
+	*/
+	update(data, inputEncoding) {
+		if (this._finalized) {
+			throw new Error("Sign was already finalized");
+		}
+		this._hash.update(data, inputEncoding);
+		return this;
+	}
+	/**
+	* Compute the signature using the private key.
+	* Returns the signature as a Buffer (or string if outputEncoding is given).
+	*/
+	sign(privateKey, outputEncoding) {
+		if (this._finalized) {
+			throw new Error("Sign was already finalized");
+		}
+		this._finalized = true;
+		const digest = this._hash.digest();
+		const pem = extractPem(privateKey);
+		const parsed = parsePemKey(pem);
+		if (parsed.type !== "rsa-private") {
+			throw new Error("privateKey must be an RSA private key");
+		}
+		const { n, e, d } = parsed.components;
+		const keyLen = rsaKeySize(n);
+		const prefix = DIGEST_INFO_PREFIX[this._algorithm];
+		const digestInfo = new Uint8Array(prefix.length + digest.length);
+		digestInfo.set(prefix, 0);
+		digestInfo.set(digest, prefix.length);
+		const padLen = keyLen - digestInfo.length - 3;
+		if (padLen < 8) {
+			throw new Error("Key is too short for the specified hash algorithm");
+		}
+		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(digestInfo, 3 + padLen);
+		const m = bytesToBigInt(em);
+		const s = modPow(m, d, n);
+		const sigBytes = bigIntToBytes(s, keyLen);
+		const sigBuf = Buffer.from(sigBytes);
+		if (outputEncoding) {
+			return sigBuf.toString(outputEncoding);
+		}
+		return sigBuf;
+	}
+};
+/**
+* The Verify class verifies RSA PKCS#1 v1.5 signatures.
+*
+* Usage:
+*   const verify = createVerify('RSA-SHA256');
+*   verify.update('data');
+*   const ok = verify.verify(publicKey, signature);
+*/
+var Verify = class {
+	_algorithm;
+	_hash;
+	_finalized = false;
+	constructor(algorithm) {
+		this._algorithm = normalizeSignAlgorithm(algorithm);
+		this._hash = new Hash(this._algorithm);
+	}
+	/**
+	* Update the Verify object with the given data.
+	*/
+	update(data, inputEncoding) {
+		if (this._finalized) {
+			throw new Error("Verify was already finalized");
+		}
+		this._hash.update(data, inputEncoding);
+		return this;
+	}
+	/**
+	* Verify the signature against the public key.
+	* Returns true if the signature is valid, false otherwise.
+	*/
+	verify(publicKey, signature, signatureEncoding) {
+		if (this._finalized) {
+			throw new Error("Verify was already finalized");
+		}
+		this._finalized = true;
+		const digest = this._hash.digest();
+		const pem = extractPem(publicKey);
+		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("publicKey must be an RSA public or private key");
+		}
+		const keyLen = rsaKeySize(n);
+		let sigBytes;
+		if (typeof signature === "string") {
+			sigBytes = Buffer.from(signature, signatureEncoding || "base64");
+		} else {
+			sigBytes = signature instanceof Uint8Array ? signature : Buffer.from(signature);
+		}
+		if (sigBytes.length !== keyLen) {
+			return false;
+		}
+		const s = bytesToBigInt(sigBytes);
+		if (s >= n) {
+			return false;
+		}
+		const m = modPow(s, e, n);
+		const em = bigIntToBytes(m, keyLen);
+		if (em[0] !== 0 || em[1] !== 1) {
+			return false;
+		}
+		let sepIdx = 2;
+		while (sepIdx < em.length && em[sepIdx] === 255) {
+			sepIdx++;
+		}
+		if (sepIdx >= em.length || em[sepIdx] !== 0) {
+			return false;
+		}
+		if (sepIdx - 2 < 8) {
+			return false;
+		}
+		sepIdx++;
+		const recoveredDigestInfo = em.slice(sepIdx);
+		const prefix = DIGEST_INFO_PREFIX[this._algorithm];
+		const expectedDigestInfo = new Uint8Array(prefix.length + digest.length);
+		expectedDigestInfo.set(prefix, 0);
+		expectedDigestInfo.set(digest, prefix.length);
+		if (recoveredDigestInfo.length !== expectedDigestInfo.length) {
+			return false;
+		}
+		let diff = 0;
+		for (let i = 0; i < recoveredDigestInfo.length; i++) {
+			diff |= recoveredDigestInfo[i] ^ expectedDigestInfo[i];
+		}
+		return diff === 0;
+	}
+};
+/**
+* Create and return a Sign object for the given algorithm.
+*/
 function createSign(algorithm) {
-  return new Sign(algorithm);
+	return new Sign(algorithm);
 }
+/**
+* Create and return a Verify object for the given algorithm.
+*/
 function createVerify(algorithm) {
-  return new Verify(algorithm);
+	return new Verify(algorithm);
 }
-export {
-  Sign,
-  Verify,
-  createSign,
-  createVerify
-};
+
+//#endregion
+export { Sign, Verify, createSign, createVerify };

package/lib/esm/timing-safe-equal.js

@@ -1,13 +1,18 @@
+//#region src/timing-safe-equal.ts
+/**
+* Compare two buffers in constant time to prevent timing attacks.
+* Both buffers must have the same length.
+*/
 function timingSafeEqual(a, b) {
-  if (a.length !== b.length) {
-    throw new RangeError("Input buffers must have the same byte length");
-  }
-  let result = 0;
-  for (let i = 0; i < a.length; i++) {
-    result |= a[i] ^ b[i];
-  }
-  return result === 0;
+	if (a.length !== b.length) {
+		throw new RangeError("Input buffers must have the same byte length");
+	}
+	let result = 0;
+	for (let i = 0; i < a.length; i++) {
+		result |= a[i] ^ b[i];
+	}
+	return result === 0;
 }
-export {
-  timingSafeEqual
-};
+
+//#endregion
+export { timingSafeEqual };