@utilix-tech/sdk 0.1.0

package/dist/tools/hashing.cjs

@@ -0,0 +1,259 @@
+'use strict';
+
+var crypto = require('crypto');
+var md5 = require('blueimp-md5');
+var bcrypt = require('bcryptjs');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var md5__default = /*#__PURE__*/_interopDefault(md5);
+var bcrypt__default = /*#__PURE__*/_interopDefault(bcrypt);
+
+// src/tools/hashing.ts
+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 crypto.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__default.default(input),
+    bits: 128
+  };
+  return [md5Result, ...subtleResults];
+}
+async function hashOne(algorithm, input) {
+  if (algorithm === "MD5") return md5__default.default(input);
+  return digestNode(algorithm, input);
+}
+var ROUND_OPTIONS = [8, 10, 12, 14];
+async function hashPassword(password, rounds = 10) {
+  return bcrypt__default.default.hash(password, rounds);
+}
+async function verifyPassword(password, hash) {
+  return bcrypt__default.default.compare(password, hash);
+}
+async function hashWithTiming(password, rounds) {
+  const start = Date.now();
+  const hash = await bcrypt__default.default.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__default.default(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);
+}
+
+exports.HASH_ALGORITHMS = HASH_ALGORITHMS;
+exports.HASH_BITS = HASH_BITS;
+exports.ROUND_OPTIONS = ROUND_OPTIONS;
+exports.createEntry = createEntry;
+exports.generateBcryptHash = generateBcryptHash;
+exports.generateHtpasswdFile = generateHtpasswdFile;
+exports.generateMd5Hash = generateMd5Hash;
+exports.generatePlain = generatePlain;
+exports.generateSha1Hash = generateSha1Hash;
+exports.hashAll = hashAll;
+exports.hashOne = hashOne;
+exports.hashPassword = hashPassword;
+exports.hashWithTiming = hashWithTiming;
+exports.parseHtpasswdFile = parseHtpasswdFile;
+exports.validateRounds = validateRounds;
+exports.validateUsername = validateUsername;
+exports.verifyPassword = verifyPassword;

package/dist/tools/hashing.d.cts

@@ -0,0 +1 @@
+export { B as BcryptResult, H as HASH_ALGORITHMS, a as HASH_BITS, b as HashAlgorithm, c as HashResult, d as HtpasswdAlgorithm, e as HtpasswdEntry, R as ROUND_OPTIONS, f as createEntry, g as generateBcryptHash, i as generateHtpasswdFile, j as generateMd5Hash, k as generatePlain, l as generateSha1Hash, m as hashAll, n as hashOne, o as hashPassword, p as hashWithTiming, q as parseHtpasswdFile, v as validateRounds, r as validateUsername, s as verifyPassword } from '../hashing-CnetQFD_.cjs';

package/dist/tools/hashing.d.ts

@@ -0,0 +1 @@
+export { B as BcryptResult, H as HASH_ALGORITHMS, a as HASH_BITS, b as HashAlgorithm, c as HashResult, d as HtpasswdAlgorithm, e as HtpasswdEntry, R as ROUND_OPTIONS, f as createEntry, g as generateBcryptHash, i as generateHtpasswdFile, j as generateMd5Hash, k as generatePlain, l as generateSha1Hash, m as hashAll, n as hashOne, o as hashPassword, p as hashWithTiming, q as parseHtpasswdFile, v as validateRounds, r as validateUsername, s as verifyPassword } from '../hashing-CnetQFD_.js';

package/dist/tools/hashing.js

@@ -0,0 +1,2 @@
+export { HASH_ALGORITHMS, HASH_BITS, ROUND_OPTIONS, createEntry, generateBcryptHash, generateHtpasswdFile, generateMd5Hash, generatePlain, generateSha1Hash, hashAll, hashOne, hashPassword, hashWithTiming, parseHtpasswdFile, validateRounds, validateUsername, verifyPassword } from '../chunk-FL53T24A.js';
+import '../chunk-MLKGABMK.js';