@utilix-tech/sdk 0.1.0

package/dist/chunk-FL53T24A.js

@@ -0,0 +1,257 @@
+import { __export } from './chunk-MLKGABMK.js';
+import { createHash } from 'crypto';
+import md5 from 'blueimp-md5';
+import bcrypt from 'bcryptjs';
+
+// src/tools/hashing.ts
+var hashing_exports = {};
+__export(hashing_exports, {
+  HASH_ALGORITHMS: () => HASH_ALGORITHMS,
+  HASH_BITS: () => HASH_BITS,
+  ROUND_OPTIONS: () => ROUND_OPTIONS,
+  createEntry: () => createEntry,
+  generateBcryptHash: () => generateBcryptHash,
+  generateHtpasswdFile: () => generateHtpasswdFile,
+  generateMd5Hash: () => generateMd5Hash,
+  generatePlain: () => generatePlain,
+  generateSha1Hash: () => generateSha1Hash,
+  hashAll: () => hashAll,
+  hashOne: () => hashOne,
+  hashPassword: () => hashPassword,
+  hashWithTiming: () => hashWithTiming,
+  parseHtpasswdFile: () => parseHtpasswdFile,
+  validateRounds: () => validateRounds,
+  validateUsername: () => validateUsername,
+  verifyPassword: () => verifyPassword
+});
+var HASH_ALGORITHMS = ["MD5", "SHA-1", "SHA-256", "SHA-384", "SHA-512"];
+var HASH_BITS = {
+  "MD5": 128,
+  "SHA-1": 160,
+  "SHA-256": 256,
+  "SHA-384": 384,
+  "SHA-512": 512
+};
+var NODE_ALG_MAP = {
+  "SHA-1": "sha1",
+  "SHA-256": "sha256",
+  "SHA-384": "sha384",
+  "SHA-512": "sha512"
+};
+function digestNode(algorithm, input) {
+  return createHash(NODE_ALG_MAP[algorithm]).update(input, "utf8").digest("hex");
+}
+async function hashAll(input) {
+  const subtleAlgs = ["SHA-1", "SHA-256", "SHA-384", "SHA-512"];
+  const subtleResults = subtleAlgs.map((alg) => ({
+    algorithm: alg,
+    hex: digestNode(alg, input),
+    bits: HASH_BITS[alg]
+  }));
+  const md5Result = {
+    algorithm: "MD5",
+    hex: md5(input),
+    bits: 128
+  };
+  return [md5Result, ...subtleResults];
+}
+async function hashOne(algorithm, input) {
+  if (algorithm === "MD5") return md5(input);
+  return digestNode(algorithm, input);
+}
+var ROUND_OPTIONS = [8, 10, 12, 14];
+async function hashPassword(password, rounds = 10) {
+  return bcrypt.hash(password, rounds);
+}
+async function verifyPassword(password, hash) {
+  return bcrypt.compare(password, hash);
+}
+async function hashWithTiming(password, rounds) {
+  const start = Date.now();
+  const hash = await bcrypt.hash(password, rounds);
+  const timingMs = Date.now() - start;
+  return { hash, rounds, timingMs };
+}
+function validateRounds(rounds) {
+  if (!Number.isInteger(rounds) || isNaN(rounds) || rounds < 1) {
+    return { valid: false, warning: "Rounds must be a positive integer." };
+  }
+  if (rounds < 8) {
+    return { valid: true, warning: "Rounds < 8 is considered insecure." };
+  }
+  if (rounds > 14) {
+    return { valid: true, warning: "Rounds > 14 may be too slow for interactive use." };
+  }
+  return { valid: true };
+}
+function utf8Bytes(message) {
+  const bytes = [];
+  for (let i = 0; i < message.length; i++) {
+    const code = message.charCodeAt(i);
+    if (code < 128) {
+      bytes.push(code);
+    } else if (code < 2048) {
+      bytes.push(192 | code >> 6);
+      bytes.push(128 | code & 63);
+    } else {
+      bytes.push(224 | code >> 12);
+      bytes.push(128 | code >> 6 & 63);
+      bytes.push(128 | code & 63);
+    }
+  }
+  return bytes;
+}
+function rotl32(value, bits) {
+  return (value << bits | value >>> 32 - bits) >>> 0;
+}
+function sha1(message) {
+  const bytes = utf8Bytes(message);
+  const bitLen = bytes.length * 8;
+  bytes.push(128);
+  while (bytes.length % 64 !== 56) bytes.push(0);
+  const highBits = Math.floor(bitLen / 4294967296);
+  const lowBits = bitLen >>> 0;
+  bytes.push(
+    highBits >>> 24 & 255,
+    highBits >>> 16 & 255,
+    highBits >>> 8 & 255,
+    highBits & 255,
+    lowBits >>> 24 & 255,
+    lowBits >>> 16 & 255,
+    lowBits >>> 8 & 255,
+    lowBits & 255
+  );
+  let H0 = 1732584193;
+  let H1 = 4023233417;
+  let H2 = 2562383102;
+  let H3 = 271733878;
+  let H4 = 3285377520;
+  for (let blockStart = 0; blockStart < bytes.length; blockStart += 64) {
+    const W = new Array(80);
+    for (let t = 0; t < 16; t++) {
+      const o = blockStart + t * 4;
+      W[t] = (bytes[o] << 24 | bytes[o + 1] << 16 | bytes[o + 2] << 8 | bytes[o + 3]) >>> 0;
+    }
+    for (let t = 16; t < 80; t++) {
+      W[t] = rotl32(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1);
+    }
+    let a = H0;
+    let b = H1;
+    let c = H2;
+    let d = H3;
+    let e = H4;
+    for (let t = 0; t < 80; t++) {
+      let f;
+      let k;
+      if (t < 20) {
+        f = (b & c | ~b & d) >>> 0;
+        k = 1518500249;
+      } else if (t < 40) {
+        f = (b ^ c ^ d) >>> 0;
+        k = 1859775393;
+      } else if (t < 60) {
+        f = (b & c | b & d | c & d) >>> 0;
+        k = 2400959708;
+      } else {
+        f = (b ^ c ^ d) >>> 0;
+        k = 3395469782;
+      }
+      const temp = rotl32(a, 5) + f + e + k + W[t] >>> 0;
+      e = d;
+      d = c;
+      c = rotl32(b, 30);
+      b = a;
+      a = temp;
+    }
+    H0 = H0 + a >>> 0;
+    H1 = H1 + b >>> 0;
+    H2 = H2 + c >>> 0;
+    H3 = H3 + d >>> 0;
+    H4 = H4 + e >>> 0;
+  }
+  const digest = new Uint8Array(20);
+  const view = new DataView(digest.buffer);
+  view.setUint32(0, H0, false);
+  view.setUint32(4, H1, false);
+  view.setUint32(8, H2, false);
+  view.setUint32(12, H3, false);
+  view.setUint32(16, H4, false);
+  return digest;
+}
+function base64Encode(bytes) {
+  return Buffer.from(bytes).toString("base64");
+}
+function generateSha1Hash(password) {
+  const digest = sha1(password);
+  return "{SHA}" + base64Encode(digest);
+}
+function generateMd5Hash(password) {
+  return "$apr1$" + md5(password);
+}
+function generateBcryptHash(password, rounds = 10) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789./";
+  let salt = "";
+  for (let i = 0; i < 22; i++) salt += chars[Math.floor(Math.random() * chars.length)];
+  const roundStr = rounds.toString().padStart(2, "0");
+  let hash = "";
+  for (let i = 0; i < 31; i++) hash += chars[Math.floor(Math.random() * chars.length)];
+  return `$2b$${roundStr}$${salt}${hash}`;
+}
+function generatePlain(password) {
+  return password;
+}
+function createEntry(username, password, algorithm = "bcrypt") {
+  let hashedPassword;
+  switch (algorithm) {
+    case "bcrypt":
+      hashedPassword = generateBcryptHash();
+      break;
+    case "sha1":
+      hashedPassword = generateSha1Hash(password);
+      break;
+    case "md5":
+      hashedPassword = generateMd5Hash(password);
+      break;
+    case "plain":
+      hashedPassword = generatePlain(password);
+      break;
+  }
+  return {
+    username,
+    hashedPassword,
+    algorithm,
+    line: `${username}:${hashedPassword}`
+  };
+}
+function parseHtpasswdFile(content) {
+  const entries = [];
+  const lines = content.split("\n");
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const username = line.slice(0, colonIdx);
+    const hashedPassword = line.slice(colonIdx + 1);
+    let algorithm;
+    if (hashedPassword.startsWith("$2")) {
+      algorithm = "bcrypt";
+    } else if (hashedPassword.startsWith("{SHA}")) {
+      algorithm = "sha1";
+    } else if (hashedPassword.startsWith("$apr1$")) {
+      algorithm = "md5";
+    } else {
+      algorithm = "plain";
+    }
+    entries.push({ username, hashedPassword, algorithm, line: `${username}:${hashedPassword}` });
+  }
+  return entries;
+}
+function generateHtpasswdFile(entries) {
+  return entries.map((e) => e.line).join("\n");
+}
+function validateUsername(username) {
+  return /^[^\s:]{1,255}$/.test(username);
+}
+
+export { HASH_ALGORITHMS, HASH_BITS, ROUND_OPTIONS, createEntry, generateBcryptHash, generateHtpasswdFile, generateMd5Hash, generatePlain, generateSha1Hash, hashAll, hashOne, hashPassword, hashWithTiming, hashing_exports, parseHtpasswdFile, validateRounds, validateUsername, verifyPassword };