@gjsify/crypto 0.1.0

package/lib/esm/constants.js

@@ -0,0 +1,15 @@
+const constants = {
+  // RSA padding modes (stubs for compatibility)
+  RSA_PKCS1_PADDING: 1,
+  RSA_NO_PADDING: 3,
+  RSA_PKCS1_OAEP_PADDING: 4,
+  RSA_PKCS1_PSS_PADDING: 6,
+  // DiffieHellman error codes
+  DH_CHECK_P_NOT_SAFE_PRIME: 2,
+  DH_CHECK_P_NOT_PRIME: 1,
+  DH_UNABLE_TO_CHECK_GENERATOR: 4,
+  DH_NOT_SUITABLE_GENERATOR: 8
+};
+export {
+  constants
+};

package/lib/esm/crypto-utils.js

@@ -0,0 +1,47 @@
+import { Buffer } from "node:buffer";
+function normalizeAlgorithm(algorithm) {
+  return algorithm.toLowerCase().replace(/-/g, "");
+}
+const DIGEST_SIZES = {
+  md5: 16,
+  sha1: 20,
+  sha256: 32,
+  sha384: 48,
+  sha512: 64
+};
+const BLOCK_SIZES = {
+  md5: 64,
+  sha1: 64,
+  sha256: 64,
+  sha384: 128,
+  sha512: 128
+};
+const SUPPORTED_ALGORITHMS = /* @__PURE__ */ new Set(["md5", "sha1", "sha256", "sha384", "sha512"]);
+function hashSize(algo) {
+  const normalized = normalizeAlgorithm(algo);
+  const size = DIGEST_SIZES[normalized];
+  if (size === void 0) {
+    throw new Error(`Unknown hash algorithm: ${algo}`);
+  }
+  return size;
+}
+function toBuffer(input, encoding) {
+  if (typeof input === "string") {
+    return Buffer.from(input, encoding || "utf8");
+  }
+  if (input instanceof DataView) {
+    return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+  }
+  if (input instanceof ArrayBuffer) {
+    return Buffer.from(input);
+  }
+  return Buffer.from(input);
+}
+export {
+  BLOCK_SIZES,
+  DIGEST_SIZES,
+  SUPPORTED_ALGORITHMS,
+  hashSize,
+  normalizeAlgorithm,
+  toBuffer
+};

package/lib/esm/dh.js

@@ -0,0 +1,411 @@
+import { Buffer } from "node:buffer";
+import { randomBytes } from "./random.js";
+import { modPow } from "./bigint-math.js";
+const PREDEFINED_GROUPS = {
+  // RFC 2409 Section 6.1 — 768-bit MODP Group
+  modp1: {
+    gen: "02",
+    prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a3620ffffffffffffffff"
+  },
+  // RFC 2409 Section 6.2 — 1024-bit MODP Group
+  modp2: {
+    gen: "02",
+    prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece65381ffffffffffffffff"
+  },
+  // RFC 3526 Section 2 — 1536-bit MODP Group
+  modp5: {
+    gen: "02",
+    prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca237327ffffffffffffffff"
+  },
+  // RFC 3526 Section 3 — 2048-bit MODP Group
+  modp14: {
+    gen: "02",
+    prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff"
+  },
+  // RFC 3526 Section 4 — 3072-bit MODP Group
+  modp15: {
+    gen: "02",
+    prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff"
+  },
+  // RFC 3526 Section 5 — 4096-bit MODP Group
+  modp16: {
+    gen: "02",
+    prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff"
+  },
+  // RFC 3526 Section 6 — 6144-bit MODP Group
+  modp17: {
+    gen: "02",
+    prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff"
+  },
+  // RFC 3526 Section 7 — 8192-bit MODP Group
+  modp18: {
+    gen: "02",
+    prime: "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"
+  }
+};
+function hexToBigInt(hex) {
+  if (hex.length === 0) return 0n;
+  return BigInt("0x" + hex);
+}
+function bigIntToBuffer(n) {
+  if (n === 0n) return Buffer.from([0]);
+  let hex = n.toString(16);
+  if (hex.length % 2 !== 0) {
+    hex = "0" + hex;
+  }
+  return Buffer.from(hex, "hex");
+}
+function bufferToBigInt(buf) {
+  if (buf.length === 0) return 0n;
+  const hex = Buffer.from(buf).toString("hex");
+  if (hex.length === 0) return 0n;
+  return BigInt("0x" + hex);
+}
+function bitLength(n) {
+  if (n === 0n) return 0;
+  return n.toString(2).length;
+}
+const SMALL_PRIMES = [];
+{
+  const limit = 1e3;
+  const sieve = new Uint8Array(limit + 1);
+  for (let i = 2; i * i <= limit; i++) {
+    if (!sieve[i]) {
+      for (let j = i * i; j <= limit; j += i) {
+        sieve[j] = 1;
+      }
+    }
+  }
+  for (let i = 2; i <= limit; i++) {
+    if (!sieve[i]) SMALL_PRIMES.push(i);
+  }
+}
+function simpleSieve(n) {
+  for (const p of SMALL_PRIMES) {
+    const bp = BigInt(p);
+    if (n % bp === 0n) {
+      return n === bp;
+    }
+  }
+  return true;
+}
+function fermatTest(n) {
+  return modPow(2n, n - 1n, n) === 1n;
+}
+function millerRabinTest(n) {
+  if (n < 2n) return false;
+  if (n === 2n || n === 3n) return true;
+  if (n % 2n === 0n) return false;
+  let d = n - 1n;
+  let r = 0;
+  while (d % 2n === 0n) {
+    d /= 2n;
+    r++;
+  }
+  const witnesses = [2n, 3n, 5n, 7n, 11n, 13n];
+  for (const a of witnesses) {
+    if (a >= n) continue;
+    let x = modPow(a, d, n);
+    if (x === 1n || x === n - 1n) continue;
+    let composite = true;
+    for (let i = 0; i < r - 1; i++) {
+      x = modPow(x, 2n, n);
+      if (x === n - 1n) {
+        composite = false;
+        break;
+      }
+    }
+    if (composite) return false;
+  }
+  return true;
+}
+const DH_CHECK_P_NOT_PRIME = 1;
+const DH_CHECK_P_NOT_SAFE_PRIME = 2;
+const DH_NOT_SUITABLE_GENERATOR = 8;
+const DH_UNABLE_TO_CHECK_GENERATOR = 4;
+function checkPrime(prime, generatorBuf) {
+  const genHex = generatorBuf.toString("hex");
+  let error = 0;
+  if (prime % 2n === 0n || !simpleSieve(prime) || !fermatTest(prime) || !millerRabinTest(prime)) {
+    error += DH_CHECK_P_NOT_PRIME;
+    if (genHex === "02" || genHex === "05") {
+      error += DH_NOT_SUITABLE_GENERATOR;
+    } else {
+      error += DH_UNABLE_TO_CHECK_GENERATOR;
+    }
+    return error;
+  }
+  const halfPrime = prime >> 1n;
+  if (!millerRabinTest(halfPrime)) {
+    error += DH_CHECK_P_NOT_SAFE_PRIME;
+  }
+  switch (genHex) {
+    case "02":
+      if (prime % 24n !== 11n) {
+        error += DH_NOT_SUITABLE_GENERATOR;
+      }
+      break;
+    case "05":
+      {
+        const rem = prime % 10n;
+        if (rem !== 3n && rem !== 7n) {
+          error += DH_NOT_SUITABLE_GENERATOR;
+        }
+      }
+      break;
+    default:
+      error += DH_UNABLE_TO_CHECK_GENERATOR;
+  }
+  return error;
+}
+const primeCheckCache = {};
+function getCachedCheckPrime(prime, generatorBuf) {
+  const key = generatorBuf.toString("hex") + "_" + prime.toString(16);
+  if (key in primeCheckCache) {
+    return primeCheckCache[key];
+  }
+  const result = checkPrime(prime, generatorBuf);
+  primeCheckCache[key] = result;
+  return result;
+}
+function toBuffer(value, encoding) {
+  if (Buffer.isBuffer(value)) return value;
+  if (value instanceof Uint8Array) return Buffer.from(value);
+  if (value instanceof ArrayBuffer) return Buffer.from(value);
+  if (typeof value === "string") return Buffer.from(value, encoding || "utf8");
+  if (typeof value === "number") {
+    const buf = Buffer.alloc(1);
+    buf[0] = value;
+    return buf;
+  }
+  throw new TypeError("Invalid input type");
+}
+function formatReturnValue(n, encoding) {
+  const buf = bigIntToBuffer(n);
+  if (!encoding) {
+    return buf;
+  }
+  return buf.toString(encoding);
+}
+class DiffieHellman {
+  _prime;
+  _generator;
+  _generatorBuf;
+  _primeByteLength;
+  _pubKey;
+  _privKey;
+  _primeCode;
+  _malleable;
+  constructor(prime, generator, malleable = false) {
+    this._prime = bufferToBigInt(prime);
+    this._generatorBuf = generator;
+    this._generator = bufferToBigInt(generator);
+    this._primeByteLength = prime.length;
+    this._pubKey = void 0;
+    this._privKey = void 0;
+    this._primeCode = void 0;
+    this._malleable = malleable;
+    if (!malleable) {
+      this._primeCode = 0;
+      this.setPublicKey = void 0;
+      this.setPrivateKey = void 0;
+    }
+  }
+  /**
+   * Error code from prime/generator validation.
+   * Lazily computed on first access.
+   */
+  get verifyError() {
+    if (typeof this._primeCode !== "number") {
+      this._primeCode = getCachedCheckPrime(this._prime, this._generatorBuf);
+    }
+    return this._primeCode;
+  }
+  generateKeys(encoding) {
+    if (!this._privKey) {
+      const randBuf = randomBytes(this._primeByteLength);
+      this._privKey = bufferToBigInt(randBuf);
+    }
+    this._pubKey = modPow(this._generator, this._privKey, this._prime);
+    return this.getPublicKey(encoding);
+  }
+  computeSecret(otherPublicKey, inputEncoding, outputEncoding) {
+    let otherBuf;
+    if (typeof otherPublicKey === "string") {
+      otherBuf = Buffer.from(otherPublicKey, inputEncoding || "utf8");
+    } else {
+      otherBuf = Buffer.from(otherPublicKey);
+    }
+    const other = bufferToBigInt(otherBuf);
+    if (!this._privKey) {
+      throw new Error("You must generate keys before computing a secret");
+    }
+    if (other <= 0n || other >= this._prime) {
+      throw new Error("Supplied key is too large");
+    }
+    const secret = modPow(other, this._privKey, this._prime);
+    let out = bigIntToBuffer(secret);
+    const primeLen = this._primeByteLength;
+    if (out.length < primeLen) {
+      const padded = Buffer.alloc(primeLen);
+      out.copy(padded, primeLen - out.length);
+      out = padded;
+    }
+    if (outputEncoding) {
+      return out.toString(outputEncoding);
+    }
+    return out;
+  }
+  getPrime(encoding) {
+    return formatReturnValue(this._prime, encoding);
+  }
+  getGenerator(encoding) {
+    return formatReturnValue(this._generator, encoding);
+  }
+  getPublicKey(encoding) {
+    if (!this._pubKey) {
+      throw new Error("No public key - call generateKeys() first");
+    }
+    return formatReturnValue(this._pubKey, encoding);
+  }
+  getPrivateKey(encoding) {
+    if (!this._privKey) {
+      throw new Error("No private key - call generateKeys() first");
+    }
+    return formatReturnValue(this._privKey, encoding);
+  }
+  /**
+   * Set the public key. Only available for malleable DH instances
+   * (created via createDiffieHellman, not getDiffieHellman).
+   */
+  setPublicKey(publicKey, encoding) {
+    if (!this._malleable) {
+      throw new Error("setPublicKey is not available for predefined DH groups");
+    }
+    const buf = typeof publicKey === "string" ? Buffer.from(publicKey, encoding || "utf8") : Buffer.from(publicKey);
+    this._pubKey = bufferToBigInt(buf);
+  }
+  /**
+   * Set the private key. Only available for malleable DH instances
+   * (created via createDiffieHellman, not getDiffieHellman).
+   */
+  setPrivateKey(privateKey, encoding) {
+    if (!this._malleable) {
+      throw new Error("setPrivateKey is not available for predefined DH groups");
+    }
+    const buf = typeof privateKey === "string" ? Buffer.from(privateKey, encoding || "utf8") : Buffer.from(privateKey);
+    this._privKey = bufferToBigInt(buf);
+  }
+}
+function generatePrime(bits, generator) {
+  const gen = bufferToBigInt(generator);
+  if (bits < 16) {
+    if (gen === 2n || gen === 5n) {
+      return Buffer.from([140, 123]);
+    } else {
+      return Buffer.from([140, 39]);
+    }
+  }
+  const byteLen = Math.ceil(bits / 8);
+  const ONE = 1n;
+  const TWO = 2n;
+  const FOUR = 4n;
+  const TWENTYFOUR = 24n;
+  const ELEVEN = 11n;
+  const TEN = 10n;
+  const THREE = 3n;
+  while (true) {
+    const randBuf = randomBytes(byteLen);
+    let num = bufferToBigInt(randBuf);
+    while (bitLength(num) > bits) {
+      num >>= 1n;
+    }
+    if (num % TWO === 0n) {
+      num += ONE;
+    }
+    if (!(num & TWO)) {
+      num += TWO;
+    }
+    if (gen === TWO) {
+      while (num % TWENTYFOUR !== ELEVEN) {
+        num += FOUR;
+      }
+    } else if (gen === 5n) {
+      while (num % TEN !== THREE) {
+        num += FOUR;
+      }
+    }
+    const n2 = num >> 1n;
+    if (simpleSieve(n2) && simpleSieve(num) && fermatTest(n2) && fermatTest(num) && millerRabinTest(n2) && millerRabinTest(num)) {
+      return bigIntToBuffer(num);
+    }
+  }
+}
+const VALID_ENCODINGS = {
+  binary: true,
+  hex: true,
+  base64: true,
+  latin1: true,
+  utf8: true,
+  "utf-8": true,
+  base64url: true,
+  ascii: true,
+  ucs2: true,
+  "ucs-2": true,
+  utf16le: true,
+  "utf-16le": true
+};
+function createDiffieHellman(prime, primeEncoding, generator, generatorEncoding) {
+  if (primeEncoding !== void 0 && typeof primeEncoding !== "number" && (Buffer.isBuffer(primeEncoding) || primeEncoding instanceof Uint8Array || typeof primeEncoding === "string" && !(primeEncoding in VALID_ENCODINGS))) {
+    return createDiffieHellman(
+      prime,
+      "binary",
+      primeEncoding,
+      generator
+    );
+  }
+  const enc = primeEncoding || "binary";
+  const genc = generatorEncoding || "binary";
+  let genBuf = Buffer.from([2]);
+  if (generator !== void 0) {
+    if (typeof generator === "number") {
+      genBuf = Buffer.alloc(1);
+      genBuf[0] = generator;
+    } else if (!Buffer.isBuffer(generator)) {
+      genBuf = Buffer.from(generator, genc);
+    } else {
+      genBuf = generator;
+    }
+  }
+  if (typeof prime === "number") {
+    const primeBuf2 = generatePrime(prime, genBuf);
+    return new DiffieHellman(primeBuf2, genBuf, true);
+  }
+  let primeBuf;
+  if (Buffer.isBuffer(prime)) {
+    primeBuf = prime;
+  } else if (prime instanceof Uint8Array) {
+    primeBuf = Buffer.from(prime);
+  } else {
+    primeBuf = Buffer.from(prime, enc);
+  }
+  return new DiffieHellman(primeBuf, genBuf, true);
+}
+function getDiffieHellman(groupName) {
+  const group = PREDEFINED_GROUPS[groupName];
+  if (!group) {
+    throw new Error(`Unknown group: ${groupName}. Supported groups: ${Object.keys(PREDEFINED_GROUPS).join(", ")}`);
+  }
+  const primeBuf = Buffer.from(group.prime, "hex");
+  const genBuf = Buffer.from(group.gen, "hex");
+  return new DiffieHellman(primeBuf, genBuf, false);
+}
+const createDiffieHellmanGroup = getDiffieHellman;
+const DiffieHellmanGroup = getDiffieHellman;
+export {
+  DiffieHellman,
+  DiffieHellmanGroup,
+  createDiffieHellman,
+  createDiffieHellmanGroup,
+  getDiffieHellman
+};