xypriss 1.0.0 → 1.1.0

package/dist/cjs/mods/toolkit/src/core/hash/hash-core.js

@@ -0,0 +1,376 @@
+'use strict';
+
+var constants = require('../../utils/constants.js');
+var randomCore = require('../random/random-core.js');
+require('../random/random-types.js');
+var crypto = require('crypto');
+require('../random/random-sources.js');
+require('nehonix-uri-processor');
+require('../../utils/memory/index.js');
+require('../../types.js');
+var hashTypes = require('./hash-types.js');
+var hashUtils = require('./hash-utils.js');
+var hashValidator = require('./hash-validator.js');
+var hashAlgorithms = require('../../algorithms/hash-algorithms.js');
+var hashSecurity = require('./hash-security.js');
+var hashAdvanced = require('./hash-advanced.js');
+var hashEntropy = require('./hash-entropy.js');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var crypto__namespace = /*#__PURE__*/_interopNamespaceDefault(crypto);
+
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) NEHONIX INC. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ * -------------------------------------------------------------------------------------------
+ */
+/**
+ * Military-grade hashing functionality with enhanced security features
+ * Modular architecture for maintainable and scalable hash operations
+ */
+class Hash {
+    // ============================================================================
+    // PUBLIC API - Main hash functions
+    // ============================================================================
+    /**
+     * Create secure hash with military-grade security options
+     *
+     * IMPORTANT: This method automatically generates a random salt
+     * when no salt is provided, resulting in different hashes for the same input.
+     * This is designed for password hashing where randomness enhances security.
+     *
+     * For consistent hashes, either:
+     * - Provide a fixed salt parameter, or
+     * - Use Hash.create() method instead
+     *
+     * @param input - The input to hash
+     * @param salt - Salt for the hash (if not provided, random salt is auto-generated)
+     * @param options - Enhanced hashing options
+     * @returns The hash in the specified format
+     */
+    static createSecureHash(input, salt, options = {}) {
+        const { strength = hashTypes.HashStrength.GOOD, memoryHard = false, quantumResistant = false, timingSafe = false, validateInput = true, secureWipe = true, algorithm = "sha256", iterations = constants.HASH_SECURITY_CONSTANTS.RECOMMENDED_ITERATIONS, pepper, outputFormat = "hex", } = options;
+        // Validate input if requested
+        if (validateInput) {
+            hashValidator.HashValidator.validateHashInput(input, options);
+        }
+        // Generate salt if not provided
+        let finalSalt = salt;
+        if (!finalSalt) {
+            const strengthConfig = hashUtils.HashUtils.getStrengthConfiguration(strength);
+            finalSalt = randomCore.SecureRandom.getRandomBytes(strengthConfig.saltLength);
+        }
+        // Prepare enhanced options
+        const enhancedOptions = {
+            ...options,
+            algorithm,
+            iterations,
+            salt: finalSalt,
+            pepper,
+            outputFormat,
+        };
+        // Route to appropriate implementation based on options
+        if (memoryHard) {
+            return hashSecurity.HashSecurity.memoryHardHash(input, {
+                ...enhancedOptions,
+                outputFormat: outputFormat === "buffer" ? "buffer" : "hex",
+            }).then((result) => {
+                Hash.handleSecureWipe(input, finalSalt, pepper, secureWipe, result);
+                return typeof result === "string"
+                    ? result
+                    : result.toString("hex");
+            });
+        }
+        if (quantumResistant) {
+            const result = hashSecurity.HashSecurity.quantumResistantHash(input, {
+                ...enhancedOptions,
+                outputFormat: outputFormat,
+            });
+            return Hash.handleSecureWipe(input, finalSalt, pepper, secureWipe, result);
+        }
+        if (timingSafe) {
+            const result = hashSecurity.HashSecurity.timingSafeHash(input, {
+                ...enhancedOptions,
+                outputFormat: outputFormat,
+            });
+            return Hash.handleSecureWipe(input, finalSalt, pepper, secureWipe, result);
+        }
+        // Standard secure hash
+        const result = hashAlgorithms.HashAlgorithms.secureHash(input, {
+            ...enhancedOptions,
+            outputFormat: outputFormat,
+        });
+        return Hash.handleSecureWipe(input, finalSalt, pepper, secureWipe, result);
+    }
+    /**
+     * Verify hash with secure comparison
+     * @param input - Input to verify
+     * @param expectedHash - Expected hash value
+     * @param salt - Salt used in original hash
+     * @param options - Verification options
+     * @returns True if hash matches
+     */
+    static verifyHash(input, expectedHash, salt, options = {}) {
+        // For async operations, we need to handle them differently
+        // Force synchronous verification by disabling async features
+        const syncOptions = {
+            ...options,
+            memoryHard: false,
+            timingSafe: false, // Disable timing-safe for verification to avoid async
+        };
+        // Generate hash using the same method as createSecureHash
+        const computedHash = Hash.createSecureHash(input, salt, syncOptions);
+        // Convert both hashes to the same format for comparison
+        const expectedStr = typeof expectedHash === "string"
+            ? expectedHash
+            : expectedHash.toString("hex");
+        const computedStr = typeof computedHash === "string"
+            ? computedHash
+            : computedHash.toString();
+        // Use timing-safe comparison
+        return hashValidator.HashValidator.timingSafeEqual(computedStr, expectedStr);
+    }
+    /**
+     * Async verify hash with secure comparison
+     * @param input - Input to verify
+     * @param expectedHash - Expected hash value
+     * @param salt - Salt used in original hash
+     * @param options - Verification options
+     * @returns Promise resolving to true if hash matches
+     */
+    static async verifyHashAsync(input, expectedHash, salt, options = {}) {
+        // Generate hash using the same method as createSecureHash
+        const computedHash = await Hash.createSecureHash(input, salt, options);
+        // Convert both hashes to the same format for comparison
+        const expectedStr = typeof expectedHash === "string"
+            ? expectedHash
+            : expectedHash.toString("hex");
+        const computedStr = typeof computedHash === "string"
+            ? computedHash
+            : computedHash.toString("hex");
+        // Use timing-safe comparison
+        return hashValidator.HashValidator.timingSafeEqual(computedStr, expectedStr);
+    }
+    /**
+     * Enhanced scrypt key derivation
+     */
+    static deriveKeyScrypt(password, salt, keyLength = 32, options = {}) {
+        const { N = 32768, r = 8, p = 1, encoding = "hex", validateStrength = true, } = options;
+        // Validate password strength if requested
+        if (validateStrength && typeof password === "string") {
+            const strength = hashValidator.HashValidator.validatePasswordStrength(password);
+            if (!strength.isSecure) {
+                console.warn("Weak password detected:", strength.issues);
+            }
+        }
+        const passwordBuffer = hashUtils.HashUtils.toBuffer(password);
+        const saltBuffer = hashUtils.HashUtils.toBuffer(salt);
+        // Use Node.js scrypt
+        const crypto = require("crypto");
+        const derivedKey = crypto.scryptSync(passwordBuffer, saltBuffer, keyLength, {
+            N,
+            r,
+            p,
+        });
+        return hashUtils.HashUtils.formatOutput(derivedKey, encoding);
+    }
+    /**
+     * Standard PBKDF2 key derivation
+     *
+     * BEHAVIOR: Uses Node.js crypto.pbkdf2Sync for reliable, standard PBKDF2 implementation.
+     * Produces consistent results and is widely compatible.
+     * With crypto:
+     * @example
+     * crypto.pbkdf2Sync(
+            password,
+            salt,
+            iterations,
+            keyLength,
+            hashFunction
+        );
+     *
+     * @param password - Password to derive key from
+     * @param salt - Salt for the derivation
+     * @param iterations - Number of iterations (default: 100000)
+     * @param keyLength - Desired key length in bytes (default: 32)
+     * @param hashFunction - Hash function to use (default: "sha256")
+     * @param outputFormat - Output format (default: "hex")
+     * @returns PBKDF2 derived key
+     */
+    static pbkdf2(password, salt, iterations = 100000, keyLength = 32, hashFunction = "sha256", outputFormat = "hex") {
+        // const crypto = require("crypto");
+        const result = crypto__namespace.pbkdf2Sync(password, salt, iterations, keyLength, hashFunction);
+        switch (outputFormat) {
+            case "hex":
+                return result.toString("hex");
+            case "base64":
+                return result.toString("base64");
+            case "buffer":
+                return result;
+            default:
+                return result.toString("hex");
+        }
+    }
+    // ============================================================================
+    // PRIVATE HELPER METHODS
+    // ============================================================================
+    /**
+     * Handle secure wipe if requested
+     * IMPORTANT: Only wipe copies, not the original salt/pepper that might be needed for verification
+     */
+    static handleSecureWipe(input, salt, pepper, secureWipe, result) {
+        if (secureWipe) {
+            // Create copies for wiping to avoid destroying original data
+            let inputCopy = input;
+            let saltCopy = undefined;
+            let pepperCopy = undefined;
+            // Only create copies for buffers (strings are immutable anyway)
+            if (Buffer.isBuffer(salt) || salt instanceof Uint8Array) {
+                saltCopy = Buffer.from(salt);
+            }
+            if (pepper &&
+                (Buffer.isBuffer(pepper) || pepper instanceof Uint8Array)) {
+                pepperCopy = Buffer.from(pepper);
+            }
+            if (Buffer.isBuffer(input) || input instanceof Uint8Array) {
+                inputCopy = Buffer.from(input);
+            }
+            // Wipe the copies, not the originals
+            hashUtils.HashUtils.performSecureWipe(inputCopy, saltCopy, pepperCopy);
+        }
+        return result;
+    }
+}
+// ============================================================================
+// KEY DERIVATION FUNCTIONS
+// ============================================================================
+/**
+ * Enhanced PBKDF2 key derivation
+ */
+Hash.deriveKeyPBKDF2 = hashSecurity.HashSecurity.memoryHardHash;
+/**
+ * Enhanced Argon2 key derivation
+ */
+Hash.deriveKeyArgon2 = hashSecurity.HashSecurity.memoryHardHash;
+// ============================================================================
+// ADVANCED SECURITY FEATURES
+// ============================================================================
+/**
+ * Hardware Security Module (HSM) compatible hashing
+ */
+Hash.hsmCompatibleHash = hashSecurity.HashSecurity.hsmCompatibleHash;
+/**
+ * Cryptographic agility hash
+ */
+Hash.agilityHash = hashAdvanced.HashAdvanced.agilityHash;
+/**
+ * Side-channel attack resistant hashing
+ */
+Hash.sideChannelResistantHash = hashAdvanced.HashAdvanced.sideChannelResistantHash;
+/**
+ * Real-time security monitoring
+ */
+Hash.monitorHashSecurity = hashSecurity.HashSecurity.monitorHashSecurity;
+// ============================================================================
+// ENTROPY AND ANALYSIS
+// ============================================================================
+/**
+ * Analyze hash entropy
+ */
+Hash.analyzeHashEntropy = hashEntropy.HashEntropy.analyzeHashEntropy;
+/**
+ * Generate entropy report
+ */
+Hash.generateEntropyReport = hashEntropy.HashEntropy.generateEntropyReport;
+/**
+ * Perform randomness tests
+ */
+Hash.performRandomnessTests = hashEntropy.HashEntropy.performRandomnessTests;
+// ============================================================================
+// VALIDATION AND UTILITIES
+// ============================================================================
+/**
+ * Validate password strength
+ */
+Hash.validatePasswordStrength = hashValidator.HashValidator.validatePasswordStrength;
+/**
+ * Timing-safe string comparison
+ */
+Hash.timingSafeEqual = hashValidator.HashValidator.timingSafeEqual;
+/**
+ * Validate salt quality
+ */
+Hash.validateSalt = hashValidator.HashValidator.validateSalt;
+// ============================================================================
+// ADVANCED ALGORITHMS
+// ============================================================================
+/**
+ * Parallel hash processing
+ */
+Hash.parallelHash = hashAdvanced.HashAdvanced.parallelHash;
+/**
+ * Streaming hash for large data
+ */
+Hash.createStreamingHash = hashAdvanced.HashAdvanced.createStreamingHash;
+/**
+ * Merkle tree hash
+ */
+Hash.merkleTreeHash = hashAdvanced.HashAdvanced.merkleTreeHash;
+/**
+ * Incremental hash
+ */
+Hash.incrementalHash = hashAdvanced.HashAdvanced.incrementalHash;
+/**
+ * Hash chain
+ */
+Hash.hashChain = hashAdvanced.HashAdvanced.hashChain;
+// ============================================================================
+// UTILITY FUNCTIONS
+// ============================================================================
+/**
+ * Format hash output
+ */
+Hash.formatOutput = hashUtils.HashUtils.formatOutput;
+/**
+ * Get strength configuration
+ */
+Hash.getStrengthConfiguration = hashUtils.HashUtils.getStrengthConfiguration;
+/**
+ * Get algorithm security level
+ */
+Hash.getAlgorithmSecurityLevel = hashUtils.HashUtils.getAlgorithmSecurityLevel;
+// ============================================================================
+// LEGACY COMPATIBILITY (for backward compatibility)
+// ============================================================================
+/**
+ * Legacy secure hash method (for backward compatibility)
+ *
+ * BEHAVIOR: Produces consistent hashes for the same input (like CryptoJS).
+ * This method does NOT auto-generate random salts, ensuring deterministic results.
+ *
+ * For password hashing with auto-salt generation, use Hash.createSecureHash() instead.
+ */
+Hash.create = hashAlgorithms.HashAlgorithms.secureHash;
+/**
+ * Legacy HMAC creation (for backward compatibility)
+ */
+Hash.createSecureHMAC = hashAlgorithms.HashAlgorithms.createSecureHMAC;
+
+exports.Hash = Hash;
+//# sourceMappingURL=hash-core.js.map

package/dist/cjs/mods/toolkit/src/core/hash/hash-core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-core.js","sources":["../../../../../../../mods/toolkit/src/core/hash/hash-core.ts"],"sourcesContent":[null],"names":["HashStrength","HASH_SECURITY_CONSTANTS","HashValidator","HashUtils","SecureRandom","HashSecurity","HashAlgorithms","crypto","HashAdvanced","HashEntropy"],"mappings":"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"}