saltpepperpass-node/dist/index.js

saltpepperpass-node is a Node.js package that securely hashes passwords using bcrypt with customizable salt length, pepper text, and hashing rounds. It enhances password security by salting and peppering before hashing, making it ideal for backend applica

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  default: () => index_default,
  generateHash: () => generateHash,
  verifyHash: () => verifyHash
});
module.exports = __toCommonJS(index_exports);

// src/hashing.ts
var import_dotenv = __toESM(require("dotenv"));
var import_bcrypt = __toESM(require("bcrypt"));

// src/salting.ts
function generateSaltingText(saltLength) {
  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+-=[]{}|;:,.<>?";
  let result = "";
  const charactersLength = characters.length;
  for (let i = 0; i < saltLength; i++) {
    result += characters.charAt(Math.floor(Math.random() * charactersLength));
  }
  return result;
}

// src/hashing.ts
import_dotenv.default.config();
function generateHash(password) {
  if (!process.env.PEPPER_TEXT) {
    throw new Error(
      "PEPPER_TEXT is not defined! Please set it in the .env file."
    );
  }
  const saltLength = parseInt(process.env.SALTING_TEXT_LENGTH || "5", 10);
  const pepperText = process.env.PEPPER_TEXT;
  const hashingRounds = parseInt(process.env.HASHING_ROUNDS || "10", 10);
  const salt = generateSaltingText(saltLength);
  const saltedAndPepperedPassword = salt + password + pepperText;
  const hash = import_bcrypt.default.hashSync(saltedAndPepperedPassword, hashingRounds);
  return { hash, saltingText: salt };
}

// src/verify.ts
var import_dotenv2 = __toESM(require("dotenv"));
var import_bcrypt2 = __toESM(require("bcrypt"));
import_dotenv2.default.config();
function verifyHash(password, salt, hash) {
  if (!process.env.PEPPER_TEXT) {
    throw new Error(
      "PEPPER_TEXT is not defined! Please set it in the .env file."
    );
  }
  const pepperText = process.env.PEPPER_TEXT;
  const saltedAndPepperedPassword = salt + password + pepperText;
  const isVerified = import_bcrypt2.default.compareSync(saltedAndPepperedPassword, hash);
  return isVerified;
}

// src/index.ts
var saltAndPepperPass = {
  generateHash,
  verifyHash
};
var index_default = saltAndPepperPass;
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  generateHash,
  verifyHash
});