fortify2-js
Version:
MOST POWERFUL JavaScript Security Library! Military-grade cryptography + 19 enhanced object methods + quantum-resistant algorithms + perfect TypeScript support. More powerful than Lodash with built-in security.
561 lines (557 loc) • 26.5 kB
JavaScript
;
var crypto = require('./core/crypto.js');
var index$4 = require('./security/secure-string/index.js');
var index$1 = require('./security/secure-object/index.js');
var index$5 = require('./security/secure-array/index.js');
var index = require('./utils/fortified-function/index.js');
var index$2 = require('./security/cache/index.js');
var ServerFactory = require('./integrations/express/ServerFactory.js');
var passwordTypes = require('./core/password/password-types.js');
var types = require('./types.js');
var randomCore = require('./core/random/random-core.js');
require('./core/random/random-types.js');
require('crypto');
require('./core/random/random-sources.js');
var Uint8Array = require('./helpers/Uint8Array.js');
var randomTokens = require('./core/random/random-tokens.js');
var randomCrypto = require('./core/random/random-crypto.js');
var keys = require('./core/keys.js');
var validators = require('./core/validators.js');
var index$3 = require('./security/index.js');
var hashCore = require('./core/hash/hash-core.js');
require('./core/hash/hash-types.js');
var encoding = require('./utils/encoding.js');
require('argon2');
require('./algorithms/hash-algorithms.js');
require('./core/password/index.js');
var rsaKeyCalculator = require('./generators/rsaKeyCalculator.js');
var patterns = require('./utils/patterns.js');
var detectInjection = require('./utils/detectInjection.js');
var passwordCore = require('./core/password/password-core.js');
var secureStringCore = require('./security/secure-string/core/secure-string-core.js');
var secureObjectCore = require('./security/secure-object/core/secure-object-core.js');
var secureArrayCore = require('./security/secure-array/core/secure-array-core.js');
var secureMemory = require('./security/secure-memory.js');
var fortifiedFunction = require('./utils/fortified-function/fortified-function.js');
var sideChannel = require('./security/side-channel.js');
var memoryHard = require('./security/memory-hard.js');
var postQuantum = require('./security/post-quantum.js');
var entropyAugmentation = require('./security/entropy-augmentation.js');
var canaryTokens = require('./security/canary-tokens.js');
var attestation = require('./security/attestation.js');
var runtimeVerification = require('./security/runtime-verification.js');
var secureSerialization = require('./security/secure-serialization.js');
var tamperEvidentLogging = require('./security/tamper-evident-logging.js');
var sensitiveKeys = require('./security/secure-object/encryption/sensitive-keys.js');
var cryptoHandler = require('./security/secure-object/encryption/crypto-handler.js');
var metadataManager = require('./security/secure-object/metadata/metadata-manager.js');
var eventManager = require('./security/secure-object/events/event-manager.js');
var serializationHandler = require('./security/secure-object/serialization/serialization-handler.js');
var idGenerator = require('./security/secure-object/utils/id-generator.js');
var validation = require('./security/secure-object/utils/validation.js');
var cache_config = require('./security/cache/config/cache.config.js');
var useCache = require('./security/cache/useCache.js');
var UFSIMC = require('./security/cache/UFSIMC.js');
var cacheSys = require('./security/cache/cacheSys.js');
/***************************************************************************
* FortifyJS - Secure Array Types
*
* This file contains type definitions for the SecureArray architecture
*
* @author Nehonix
* @license MIT
*
* Copyright (c) 2025 Nehonix. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
***************************************************************************** */
/**
* FortifyJS Main Module
*
* This is the main entry point for the FortifyJS library. It provides
* access to all the core and advanced security features of the library.
*
* FortifyJS is designed to be a comprehensive cryptographic security library
* that provides secure token generation, advanced hashing, key derivation,
* password utilities, and more.
*
* It is built with TypeScript and designed for maximum security, performance,
* and developer experience.
*
* @NEHONIX
* @augments FortifyJS
* @exports Fortify
* @author Nehonix
* @see https://lab.nehonix.space
* @name FortifyJS
* @example
* ```typescript
* import { FortifyJS } from "fortify-js";
*
* // Generate a secure token
* const token = FortifyJS.generateSecureToken({
* length: 32,
* entropy: "maximum",
* });
* console.log(token);
* // Output: "aK7mN9pQ2rS8tU3vW6xY1zB4cD5eF7gH"
* ```
*/
// Crypto compatibility exports for easy migration from crypto module
// Export individual methods to ensure they're available
const createSecureCipheriv = randomCrypto.RandomCrypto.createSecureCipheriv;
const createSecureDecipheriv = randomCrypto.RandomCrypto.createSecureDecipheriv;
const generateSecureIV = randomCrypto.RandomCrypto.generateSecureIV;
const generateSecureIVBatch = randomCrypto.RandomCrypto.generateSecureIVBatch;
const generateSecureIVForAlgorithm = randomCrypto.RandomCrypto.generateSecureIVForAlgorithm;
const generateSecureIVBatchForAlgorithm = randomCrypto.RandomCrypto.generateSecureIVBatchForAlgorithm;
const validateIV = randomCrypto.RandomCrypto.validateIV;
const getRandomBytes = randomCore.SecureRandom.getRandomBytes;
const generateSessionToken = randomTokens.RandomTokens.generateSessionToken;
const generateSecureUUID = randomCore.SecureRandom.generateSecureUUID;
// Hash methods from Hash class
const createSecureHash = hashCore.Hash.createSecureHash;
const createSecureHMAC = hashCore.Hash.createSecureHMAC;
const verifyHash = hashCore.Hash.verifyHash;
// alias for password manager (useful for legacy code)
/**
* Fast password manager access but use default configuration
* for custom config, use PasswordManager.create() or PasswordManager.getInstance()
*/
const pm = passwordCore.PasswordManager.getInstance();
/**
* @author iDevo
* @description Creates a secure string that can be explicitly cleared from memory
* @param str - The string to be converted to a secure string
* @returns A new SecureString instance
*/
function fString(...args) {
return index$4.createSecureString(...args);
}
/**
* @author iDevo
* @description Creates a secure object that can be explicitly cleared from memory
* @param initialData - The initial data to be stored in the secure object
* @returns A new SecureObject instance
*/
function fObject(...args) {
return index$1.createSecureObject(...args);
}
/**
* @author Nehonix
* @description Creates a secure array that can store sensitive data with enhanced security features
* @param initialData - The initial data to be stored in the secure array
* @returns A new SecureArray instance
*/
function fArray(...args) {
return index$5.createSecureArray(...args);
}
/**
* Encrypt a password with pepper and military-grade hashing
*
* This function provides an additional layer of security by applying a pepper (secret)
* before hashing the password with Argon2ID. This protects against rainbow table attacks
* even if the database is compromised.
*
* @author suppercodercodelover
* @param password - The plain text password to encrypt
* @param PEPPER - A secret pepper value (should be stored securely, not in database)
* @returns Promise<string> - The peppered and hashed password ready for database storage
* @throws Error if PEPPER is not provided
*
* @example
* ```typescript
* // Create pepper using Random
* console.log("PASSWORD_PEPPER: ", Random.getRandomBytes(16)) // replace "16" with desired length then store securely (example in a .env file)
* const pepper = process.env.PASSWORD_PEPPER; // Store securely!
* const hashedPassword = await encryptSecurePass("userPassword123", pepper);
* // Store hashedPassword in database
* ```
*
* @security
* - Uses HMAC-SHA256 for pepper application
* - Uses Argon2ID for final password hashing
* - Timing-safe operations prevent side-channel attacks
*/
async function encryptSecurePass(password, PEPPER, options = {}) {
if (!PEPPER) {
throw new Error("PEPPER must be defined when running password master. Store it securely in environment variables.");
}
// Apply pepper using HMAC-SHA256 for cryptographic security
const peppered = hashCore.Hash.createSecureHMAC("sha256", PEPPER, password);
// Hash the peppered password with Argon2ID (military-grade)
return await pm.hash(peppered, options);
}
/**
* Verify a password against a peppered hash with timing-safe comparison
*
* This function verifies a plain text password against a hash that was created
* using encryptSecurePass(). It applies the same pepper and uses constant-time
* verification to prevent timing attacks.
*
* @author suppercodercodelover
* @param password - The plain text password to verify
* @param hashedPassword - The peppered hash from database (created with encryptSecurePass)
* @param PEPPER - The same secret pepper value used during encryption
* @returns Promise<boolean> - true if password is valid, false otherwise
* @throws Error if PEPPER is not provided
*
* @example
* ```typescript
* const pepper = process.env.PASSWORD_PEPPER; // Same pepper as encryption
* const isValid = await verifyEncryptedPassword(
* "userPassword123",
* storedHashFromDB,
* pepper
* );
*
* if (isValid) {
* console.log("Login successful!");
* } else {
* console.log("Invalid credentials");
* }
* ```
*
* @security
* - Uses timing-safe verification (constant-time comparison)
* - Applies same HMAC-SHA256 pepper as encryption
* - Resistant to timing attacks and side-channel analysis
* - Returns boolean only (no additional timing information leaked)
*/
async function verifyEncryptedPassword(password, hashedPassword, PEPPER) {
if (!PEPPER) {
throw new Error("PEPPER must be defined when running password master. Use the same pepper as encryptSecurePass().");
}
// Apply the same pepper transformation as during encryption
const peppered = hashCore.Hash.createSecureHMAC("sha256", PEPPER, password);
// Perform timing-safe verification
const result = await pm.verify(peppered, hashedPassword);
return result.isValid;
}
// For CommonJS compatibility
if (typeof module !== "undefined" && module.exports) {
//default
module.exports.default = crypto.FortifyJS;
//
module.exports = crypto.FortifyJS;
module.exports.FortifyJS = crypto.FortifyJS;
module.exports.ftfy = crypto.FortifyJS;
module.exports.Fortify = crypto.FortifyJS;
module.exports.pm = pm;
// Export SecureRandom class and methods
module.exports.SecureRandom = randomCore.SecureRandom;
module.exports.Random = randomCore.SecureRandom;
// Export individual methods for direct access (using correct classes)
module.exports.createSecureCipheriv = randomCrypto.RandomCrypto.createSecureCipheriv;
module.exports.createSecureDecipheriv = randomCrypto.RandomCrypto.createSecureDecipheriv;
module.exports.generateSecureIV = randomCrypto.RandomCrypto.generateSecureIV;
module.exports.generateSecureIVBatch = randomCrypto.RandomCrypto.generateSecureIVBatch;
module.exports.generateSecureIVForAlgorithm =
randomCrypto.RandomCrypto.generateSecureIVForAlgorithm;
module.exports.generateSecureIVBatchForAlgorithm =
randomCrypto.RandomCrypto.generateSecureIVBatchForAlgorithm;
module.exports.validateIV = randomCrypto.RandomCrypto.validateIV;
module.exports.getRandomBytes = randomCore.SecureRandom.getRandomBytes;
module.exports.generateSessionToken = randomTokens.RandomTokens.generateSessionToken;
module.exports.generateSecureUUID = randomCore.SecureRandom.generateSecureUUID;
// Export Hash methods (consolidated from SecureRandom)
module.exports.createSecureHash = hashCore.Hash.createSecureHash;
module.exports.createSecureHMAC = hashCore.Hash.createSecureHMAC;
module.exports.verifyHash = hashCore.Hash.verifyHash;
// Export other core classes
module.exports.Hash = hashCore.Hash;
module.exports.Keys = keys.Keys;
module.exports.Validators = validators.Validators;
module.exports.SecureBuffer = secureMemory.SecureBuffer;
module.exports.Buffer = secureMemory.SecureBuffer;
module.exports.EnhancedUint8Array = Uint8Array.EnhancedUint8Array;
// Export Password Management System
module.exports.PasswordManager = passwordCore.PasswordManager;
// Export Password Management Types and Enums (using imported modules)
module.exports.PasswordAlgorithm = passwordTypes.PasswordAlgorithm;
module.exports.PasswordSecurityLevel = passwordTypes.PasswordSecurityLevel;
// Export new password utility functions
module.exports.encryptSecurePass = encryptSecurePass;
module.exports.verifyEncryptedPassword = verifyEncryptedPassword;
// ===================== safe (String and Object) ====================
// Export String, Object, Array, and Function utilities
module.exports.fString = fString;
module.exports.fObject = fObject;
module.exports.fArray = fArray;
module.exports.func = index.func;
// Export fortified function utilities (using imported modules)
module.exports.createFortifiedFunction = index.createFortifiedFunction;
module.exports.FortifiedFunction = fortifiedFunction.FortifiedFunction;
// Export Security Features (using imported modules)
globalThis.Object.keys(index$3).forEach((key) => {
if (key !== "default") {
module.exports[key] = index$3[key];
}
});
// Export Security Features (using imported modules)
globalThis.Object.keys(index$4).forEach((key) => {
if (key !== "default") {
module.exports[key] = index$4[key];
}
});
globalThis.Object.keys(index$1).forEach((key) => {
if (key !== "default") {
module.exports[key] = index$1[key];
}
});
globalThis.Object.keys(index$5).forEach((key) => {
if (key !== "default") {
module.exports[key] = index$5[key];
}
});
// Export Utils/Encoding (using imported modules)
globalThis.Object.keys(encoding).forEach((key) => {
if (key !== "default") {
module.exports[key] = encoding[key];
}
});
// Export SecureString, SecureObject, and SecureArray classes
module.exports.SecureString = secureStringCore.SecureString;
module.exports.SecureObject = secureObjectCore.SecureObject;
module.exports.SecureArray = secureArrayCore.SecureArray;
// ======================= v4.x.y =================
// Cache system
globalThis.Object.keys(index$2).forEach((key) => {
if (key !== "default") {
module.exports[key] = index$2[key];
}
});
globalThis.Object.keys(ServerFactory).forEach((key) => {
if (key !== "default") {
module.exports[key] = ServerFactory[key];
}
});
}
exports.Fortify = crypto.FortifyJS;
exports.ftfy = crypto.FortifyJS;
exports.MODULE_INFO = index$1.MODULE_INFO;
exports.SECURE_OBJECT_VERSION = index$1.SECURE_OBJECT_VERSION;
exports.cloneSecureObject = index$1.cloneSecureObject;
exports.createReadOnlySecureObject = index$1.createReadOnlySecureObject;
exports.createSecureObject = index$1.createSecureObject;
exports.createSecureObjectWithSensitiveKeys = index$1.createSecureObjectWithSensitiveKeys;
exports.createFortifiedFunction = index.createFortifiedFunction;
exports.func = index.func;
exports.CACHE_BUILD_DATE = index$2.CACHE_BUILD_DATE;
exports.CACHE_VERSION = index$2.CACHE_VERSION;
exports.Cache = index$2.Cache;
exports.cleanupFileCache = index$2.cleanupFileCache;
exports.clearAllCache = index$2.clearAllCache;
exports.clearFileCache = index$2.clearFileCache;
exports.createOptimalCache = index$2.createOptimalCache;
exports.defaultFileCache = index$2.defaultFileCache;
exports.deleteFileCache = index$2.deleteFileCache;
exports.expireCache = index$2.expireCache;
exports.filepath = index$2.filepath;
exports.generateFilePath = index$2.generateFilePath;
exports.getCacheStats = index$2.getCacheStats;
exports.getFileCacheStats = index$2.getFileCacheStats;
exports.hasFileCache = index$2.hasFileCache;
exports.readCache = index$2.readCache;
exports.readFileCache = index$2.readFileCache;
exports.removeFileCache = index$2.removeFileCache;
exports.writeCache = index$2.writeCache;
exports.writeFileCache = index$2.writeFileCache;
exports.UFSMiddleware = ServerFactory.UFSMiddleware;
exports.createCacheMiddleware = ServerFactory.createCacheMiddleware;
exports.createServer = ServerFactory.createServer;
exports.createServerInstance = ServerFactory.createServerInstance;
Object.defineProperty(exports, 'PasswordAlgorithm', {
enumerable: true,
get: function () { return passwordTypes.PasswordAlgorithm; }
});
Object.defineProperty(exports, 'PasswordSecurityLevel', {
enumerable: true,
get: function () { return passwordTypes.PasswordSecurityLevel; }
});
Object.defineProperty(exports, 'EntropySource', {
enumerable: true,
get: function () { return types.EntropySource; }
});
Object.defineProperty(exports, 'HashAlgorithm', {
enumerable: true,
get: function () { return types.HashAlgorithm; }
});
Object.defineProperty(exports, 'KeyDerivationAlgorithm', {
enumerable: true,
get: function () { return types.KeyDerivationAlgorithm; }
});
Object.defineProperty(exports, 'SecurityLevel', {
enumerable: true,
get: function () { return types.SecurityLevel; }
});
Object.defineProperty(exports, 'TokenType', {
enumerable: true,
get: function () { return types.TokenType; }
});
exports.Random = randomCore.SecureRandom;
exports.EnhancedUint8Array = Uint8Array.EnhancedUint8Array;
exports.Keys = keys.Keys;
exports.Validators = validators.Validators;
exports.Hash = hashCore.Hash;
exports.asciiToString = encoding.asciiToString;
exports.base32ToBuffer = encoding.base32ToBuffer;
exports.base58ToBuffer = encoding.base58ToBuffer;
exports.base64ToBase64Url = encoding.base64ToBase64Url;
exports.base64ToBuffer = encoding.base64ToBuffer;
exports.base64ToString = encoding.base64ToString;
exports.base64UrlToBase64 = encoding.base64UrlToBase64;
exports.base64UrlToBuffer = encoding.base64UrlToBuffer;
exports.base64UrlToString = encoding.base64UrlToString;
exports.baseToNumber = encoding.baseToNumber;
exports.binaryToBuffer = encoding.binaryToBuffer;
exports.binaryToNumber = encoding.binaryToNumber;
exports.bufferToBase32 = encoding.bufferToBase32;
exports.bufferToBase58 = encoding.bufferToBase58;
exports.bufferToBase64 = encoding.bufferToBase64;
exports.bufferToBase64Url = encoding.bufferToBase64Url;
exports.bufferToBinary = encoding.bufferToBinary;
exports.bufferToHex = encoding.bufferToHex;
exports.bufferToOctal = encoding.bufferToOctal;
exports.bufferToString = encoding.bufferToString;
exports.bufferToUrlEncoded = encoding.bufferToUrlEncoded;
exports.buffersEqual = encoding.buffersEqual;
exports.bytesToUint16 = encoding.bytesToUint16;
exports.bytesToUint32 = encoding.bytesToUint32;
exports.chunkBuffer = encoding.chunkBuffer;
exports.concatBuffers = encoding.concatBuffers;
exports.convertBase = encoding.convertBase;
exports.detectEncoding = encoding.detectEncoding;
exports.formatBytes = encoding.formatBytes;
exports.hexToBuffer = encoding.hexToBuffer;
exports.hexToString = encoding.hexToString;
exports.numberToBase = encoding.numberToBase;
exports.numberToBinary = encoding.numberToBinary;
exports.numberToOctal = encoding.numberToOctal;
exports.octalToBuffer = encoding.octalToBuffer;
exports.octalToNumber = encoding.octalToNumber;
exports.padBuffer = encoding.padBuffer;
exports.randomBuffer = encoding.randomBuffer;
exports.reverseBytes = encoding.reverseBytes;
exports.simpleChecksum = encoding.simpleChecksum;
exports.stringToAscii = encoding.stringToAscii;
exports.stringToBase64 = encoding.stringToBase64;
exports.stringToBase64Url = encoding.stringToBase64Url;
exports.stringToBuffer = encoding.stringToBuffer;
exports.stringToHex = encoding.stringToHex;
exports.uint16ToBytes = encoding.uint16ToBytes;
exports.uint32ToBytes = encoding.uint32ToBytes;
exports.urlDecode = encoding.urlDecode;
exports.urlEncode = encoding.urlEncode;
exports.xorBuffers = encoding.xorBuffers;
exports.assessRSASecurity = rsaKeyCalculator.assessRSASecurity;
exports.benchmarkRSAPerformance = rsaKeyCalculator.benchmarkRSAPerformance;
exports.calculateRSAKeySize = rsaKeyCalculator.calculateRSAKeySize;
exports.generateProtectedRSAKeyPairForData = rsaKeyCalculator.generateProtectedRSAKeyPairForData;
exports.generateRSAKeyPairForData = rsaKeyCalculator.generateRSAKeyPairForData;
exports.getEncryptionSuggestion = rsaKeyCalculator.getEncryptionSuggestion;
exports.getMaxDataSizeForRSAKey = rsaKeyCalculator.getMaxDataSizeForRSAKey;
exports.getRSARecommendations = rsaKeyCalculator.getRSARecommendations;
exports.testRSAWithDataSize = rsaKeyCalculator.testRSAWithDataSize;
exports.validateDataSizeForRSAKey = rsaKeyCalculator.validateDataSizeForRSAKey;
exports.validateRSAKeyPair = rsaKeyCalculator.validateRSAKeyPair;
exports.contexts = patterns.contexts;
exports.sqlPatterns = patterns.sqlPatterns;
exports.xssPatterns = patterns.xssPatterns;
exports.detectInjection = detectInjection.detectInjection;
exports.PasswordManager = passwordCore.PasswordManager;
exports.SecureString = secureStringCore.SecureString;
exports.SecureObject = secureObjectCore.SecureObject;
exports.SecureArray = secureArrayCore.SecureArray;
exports.Buffer = secureMemory.SecureBuffer;
exports.SecureBuffer = secureMemory.SecureBuffer;
exports.secureWipe = secureMemory.secureWipe;
exports.FortifiedFunction = fortifiedFunction.FortifiedFunction;
exports.cacheHarden = sideChannel.cacheHarden;
exports.constantTimeEqual = sideChannel.constantTimeEqual;
exports.faultResistantEqual = sideChannel.faultResistantEqual;
exports.maskedAccess = sideChannel.maskedAccess;
exports.randomDelay = sideChannel.randomDelay;
exports.secureModPow = sideChannel.secureModPow;
exports.argon2Derive = memoryHard.argon2Derive;
exports.balloonDerive = memoryHard.balloonDerive;
exports.generateKyberKeyPair = postQuantum.generateKyberKeyPair;
exports.kyberDecapsulate = postQuantum.kyberDecapsulate;
exports.kyberEncapsulate = postQuantum.kyberEncapsulate;
exports.lamportGenerateKeypair = postQuantum.lamportGenerateKeypair;
exports.lamportSign = postQuantum.lamportSign;
exports.lamportVerify = postQuantum.lamportVerify;
exports.ringLweDecrypt = postQuantum.ringLweDecrypt;
exports.ringLweEncrypt = postQuantum.ringLweEncrypt;
exports.ringLweGenerateKeypair = postQuantum.ringLweGenerateKeypair;
exports.EntropyPool = entropyAugmentation.EntropyPool;
exports.createCanary = canaryTokens.createCanary;
exports.createCanaryFunction = canaryTokens.createCanaryFunction;
exports.createCanaryObject = canaryTokens.createCanaryObject;
exports.triggerCanary = canaryTokens.triggerCanary;
exports.createAttestation = attestation.createAttestation;
exports.createLibraryAttestation = attestation.createLibraryAttestation;
exports.generateAttestationKey = attestation.generateAttestationKey;
exports.verifyAttestation = attestation.verifyAttestation;
exports.verifyLibraryAttestation = attestation.verifyLibraryAttestation;
Object.defineProperty(exports, 'SecurityIssueType', {
enumerable: true,
get: function () { return runtimeVerification.SecurityIssueType; }
});
exports.verifyRuntimeSecurity = runtimeVerification.verifyRuntimeSecurity;
exports.secureDeserialize = secureSerialization.secureDeserialize;
exports.secureSerialize = secureSerialization.secureSerialize;
Object.defineProperty(exports, 'LogLevel', {
enumerable: true,
get: function () { return tamperEvidentLogging.LogLevel; }
});
exports.TamperEvidentLogger = tamperEvidentLogging.TamperEvidentLogger;
exports.DEFAULT_SENSITIVE_KEYS = sensitiveKeys.DEFAULT_SENSITIVE_KEYS;
exports.SensitiveKeysManager = sensitiveKeys.SensitiveKeysManager;
exports.CryptoHandler = cryptoHandler.CryptoHandler;
exports.MetadataManager = metadataManager.MetadataManager;
exports.EventManager = eventManager.EventManager;
exports.SerializationHandler = serializationHandler.SerializationHandler;
exports.IdGenerator = idGenerator.IdGenerator;
exports.ValidationUtils = validation.ValidationUtils;
exports.DEFAULT_CACHE_CONFIG = cache_config.CONFIG;
exports.DEFAULT_FILE_CACHE_CONFIG = cache_config.DEFAULT_FILE_CACHE_CONFIG;
exports.SecureInMemoryCache = useCache.SecureInMemoryCache;
exports.UltraFastSecureInMemoryCache = UFSIMC.UltraFastSecureInMemoryCache;
exports.FileCache = cacheSys.FileCache;
exports.createSecureCipheriv = createSecureCipheriv;
exports.createSecureDecipheriv = createSecureDecipheriv;
exports.createSecureHMAC = createSecureHMAC;
exports.createSecureHash = createSecureHash;
exports.encryptSecurePass = encryptSecurePass;
exports.fArray = fArray;
exports.fObject = fObject;
exports.fString = fString;
exports.generateSecureIV = generateSecureIV;
exports.generateSecureIVBatch = generateSecureIVBatch;
exports.generateSecureIVBatchForAlgorithm = generateSecureIVBatchForAlgorithm;
exports.generateSecureIVForAlgorithm = generateSecureIVForAlgorithm;
exports.generateSecureUUID = generateSecureUUID;
exports.generateSessionToken = generateSessionToken;
exports.getRandomBytes = getRandomBytes;
exports.pm = pm;
exports.validateIV = validateIV;
exports.verifyEncryptedPassword = verifyEncryptedPassword;
exports.verifyHash = verifyHash;
//# sourceMappingURL=index.js.map