xypriss 1.1.0 → 1.1.3

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

@@ -1,355 +0,0 @@
-import { HASH_SECURITY_CONSTANTS } from '../../utils/constants.js';
-import { SecureRandom } from '../random/random-core.js';
-import '../random/random-types.js';
-import * as crypto from 'crypto';
-import '../random/random-sources.js';
-import 'nehonix-uri-processor';
-import '../../utils/memory/index.js';
-import '../../types.js';
-import { HashStrength } from './hash-types.js';
-import { HashUtils } from './hash-utils.js';
-import { HashValidator } from './hash-validator.js';
-import { HashAlgorithms } from '../../algorithms/hash-algorithms.js';
-import { HashSecurity } from './hash-security.js';
-import { HashAdvanced } from './hash-advanced.js';
-import { HashEntropy } from './hash-entropy.js';
-
-/* ---------------------------------------------------------------------------------------------
- *  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 = HashStrength.GOOD, memoryHard = false, quantumResistant = false, timingSafe = false, validateInput = true, secureWipe = true, algorithm = "sha256", iterations = HASH_SECURITY_CONSTANTS.RECOMMENDED_ITERATIONS, pepper, outputFormat = "hex", } = options;
-        // Validate input if requested
-        if (validateInput) {
-            HashValidator.validateHashInput(input, options);
-        }
-        // Generate salt if not provided
-        let finalSalt = salt;
-        if (!finalSalt) {
-            const strengthConfig = HashUtils.getStrengthConfiguration(strength);
-            finalSalt = 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.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.quantumResistantHash(input, {
-                ...enhancedOptions,
-                outputFormat: outputFormat,
-            });
-            return Hash.handleSecureWipe(input, finalSalt, pepper, secureWipe, result);
-        }
-        if (timingSafe) {
-            const result = HashSecurity.timingSafeHash(input, {
-                ...enhancedOptions,
-                outputFormat: outputFormat,
-            });
-            return Hash.handleSecureWipe(input, finalSalt, pepper, secureWipe, result);
-        }
-        // Standard secure hash
-        const result = 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.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.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.validatePasswordStrength(password);
-            if (!strength.isSecure) {
-                console.warn("Weak password detected:", strength.issues);
-            }
-        }
-        const passwordBuffer = HashUtils.toBuffer(password);
-        const saltBuffer = HashUtils.toBuffer(salt);
-        // Use Node.js scrypt
-        const crypto = require("crypto");
-        const derivedKey = crypto.scryptSync(passwordBuffer, saltBuffer, keyLength, {
-            N,
-            r,
-            p,
-        });
-        return 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.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.performSecureWipe(inputCopy, saltCopy, pepperCopy);
-        }
-        return result;
-    }
-}
-// ============================================================================
-// KEY DERIVATION FUNCTIONS
-// ============================================================================
-/**
- * Enhanced PBKDF2 key derivation
- */
-Hash.deriveKeyPBKDF2 = HashSecurity.memoryHardHash;
-/**
- * Enhanced Argon2 key derivation
- */
-Hash.deriveKeyArgon2 = HashSecurity.memoryHardHash;
-// ============================================================================
-// ADVANCED SECURITY FEATURES
-// ============================================================================
-/**
- * Hardware Security Module (HSM) compatible hashing
- */
-Hash.hsmCompatibleHash = HashSecurity.hsmCompatibleHash;
-/**
- * Cryptographic agility hash
- */
-Hash.agilityHash = HashAdvanced.agilityHash;
-/**
- * Side-channel attack resistant hashing
- */
-Hash.sideChannelResistantHash = HashAdvanced.sideChannelResistantHash;
-/**
- * Real-time security monitoring
- */
-Hash.monitorHashSecurity = HashSecurity.monitorHashSecurity;
-// ============================================================================
-// ENTROPY AND ANALYSIS
-// ============================================================================
-/**
- * Analyze hash entropy
- */
-Hash.analyzeHashEntropy = HashEntropy.analyzeHashEntropy;
-/**
- * Generate entropy report
- */
-Hash.generateEntropyReport = HashEntropy.generateEntropyReport;
-/**
- * Perform randomness tests
- */
-Hash.performRandomnessTests = HashEntropy.performRandomnessTests;
-// ============================================================================
-// VALIDATION AND UTILITIES
-// ============================================================================
-/**
- * Validate password strength
- */
-Hash.validatePasswordStrength = HashValidator.validatePasswordStrength;
-/**
- * Timing-safe string comparison
- */
-Hash.timingSafeEqual = HashValidator.timingSafeEqual;
-/**
- * Validate salt quality
- */
-Hash.validateSalt = HashValidator.validateSalt;
-// ============================================================================
-// ADVANCED ALGORITHMS
-// ============================================================================
-/**
- * Parallel hash processing
- */
-Hash.parallelHash = HashAdvanced.parallelHash;
-/**
- * Streaming hash for large data
- */
-Hash.createStreamingHash = HashAdvanced.createStreamingHash;
-/**
- * Merkle tree hash
- */
-Hash.merkleTreeHash = HashAdvanced.merkleTreeHash;
-/**
- * Incremental hash
- */
-Hash.incrementalHash = HashAdvanced.incrementalHash;
-/**
- * Hash chain
- */
-Hash.hashChain = HashAdvanced.hashChain;
-// ============================================================================
-// UTILITY FUNCTIONS
-// ============================================================================
-/**
- * Format hash output
- */
-Hash.formatOutput = HashUtils.formatOutput;
-/**
- * Get strength configuration
- */
-Hash.getStrengthConfiguration = HashUtils.getStrengthConfiguration;
-/**
- * Get algorithm security level
- */
-Hash.getAlgorithmSecurityLevel = 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.secureHash;
-/**
- * Legacy HMAC creation (for backward compatibility)
- */
-Hash.createSecureHMAC = HashAlgorithms.createSecureHMAC;
-
-export { Hash };
-//# sourceMappingURL=hash-core.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"hash-core.js","sources":["../../../../../../../mods/toolkit/src/core/hash/hash-core.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/esm/mods/toolkit/src/core/hash/hash-entropy.js

@@ -1,286 +0,0 @@
-import * as crypto from 'crypto';
-
-/**
- * Hash entropy analysis and quality assessment
- */
-class HashEntropy {
-    /**
-     * Advanced entropy analysis for hash quality assessment
-     * @param data - Data to analyze
-     * @returns Entropy analysis results
-     */
-    static analyzeHashEntropy(data) {
-        const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
-        const recommendations = [];
-        // Shannon entropy calculation
-        const frequency = new Map();
-        for (const byte of buffer) {
-            frequency.set(byte, (frequency.get(byte) || 0) + 1);
-        }
-        let shannonEntropy = 0;
-        const length = buffer.length;
-        for (const count of frequency.values()) {
-            const probability = count / length;
-            shannonEntropy -= probability * Math.log2(probability);
-        }
-        // Min-entropy (worst-case entropy)
-        const maxFreq = Math.max(...frequency.values());
-        const minEntropy = -Math.log2(maxFreq / length);
-        // Compression ratio test
-        const compressed = crypto.createHash("sha256").update(buffer).digest();
-        const compressionRatio = compressed.length / buffer.length;
-        // Chi-square test for randomness
-        const expected = length / 256;
-        let chiSquare = 0;
-        for (let i = 0; i < 256; i++) {
-            const observed = frequency.get(i) || 0;
-            chiSquare += Math.pow(observed - expected, 2) / expected;
-        }
-        const randomnessScore = Math.max(0, 1 - chiSquare / (256 * 4));
-        // Quality assessment
-        let qualityGrade;
-        if (shannonEntropy > 7.8 && randomnessScore > 0.9) {
-            qualityGrade = "EXCELLENT";
-        }
-        else if (shannonEntropy > 7.5 && randomnessScore > 0.8) {
-            qualityGrade = "GOOD";
-        }
-        else if (shannonEntropy > 7.0 && randomnessScore > 0.6) {
-            qualityGrade = "FAIR";
-        }
-        else {
-            qualityGrade = "POOR";
-            recommendations.push("Consider using stronger entropy sources");
-        }
-        if (minEntropy < 6) {
-            recommendations.push("Min-entropy is low, consider additional randomization");
-        }
-        if (compressionRatio > 0.8) {
-            recommendations.push("Data shows patterns, consider additional mixing");
-        }
-        return {
-            shannonEntropy,
-            minEntropy,
-            compressionRatio,
-            randomnessScore,
-            qualityGrade,
-            recommendations,
-        };
-    }
-    /**
-     * Perform statistical randomness tests
-     * @param data - Data to test
-     * @returns Test results
-     */
-    static performRandomnessTests(data) {
-        // Monobit test (frequency of 1s and 0s in binary representation)
-        const monobitResult = HashEntropy.monobitTest(data);
-        // Runs test (sequences of consecutive identical bits)
-        const runsResult = HashEntropy.runsTest(data);
-        // Frequency test (distribution of byte values)
-        const frequencyResult = HashEntropy.frequencyTest(data);
-        // Serial test (correlation between consecutive bytes)
-        const serialResult = HashEntropy.serialTest(data);
-        // Calculate overall score
-        const scores = [
-            monobitResult.score,
-            runsResult.score,
-            frequencyResult.score,
-            serialResult.score,
-        ];
-        const overallScore = scores.reduce((sum, score) => sum + score, 0) / scores.length;
-        return {
-            monobitTest: monobitResult,
-            runsTest: runsResult,
-            frequencyTest: frequencyResult,
-            serialTest: serialResult,
-            overallScore,
-        };
-    }
-    /**
-     * Monobit test - checks balance of 0s and 1s
-     * @param data - Data to test
-     * @returns Test result
-     */
-    static monobitTest(data) {
-        let ones = 0;
-        let total = 0;
-        for (const byte of data) {
-            for (let i = 0; i < 8; i++) {
-                if ((byte >> i) & 1) {
-                    ones++;
-                }
-                total++;
-            }
-        }
-        const ratio = ones / total;
-        const deviation = Math.abs(ratio - 0.5);
-        const score = Math.max(0, 1 - deviation * 4); // Scale deviation to 0-1
-        const passed = deviation < 0.1; // Within 10% of expected
-        return { passed, score };
-    }
-    /**
-     * Runs test - checks for proper distribution of runs
-     * @param data - Data to test
-     * @returns Test result
-     */
-    static runsTest(data) {
-        const bits = [];
-        // Convert to bit array
-        for (const byte of data) {
-            for (let i = 0; i < 8; i++) {
-                bits.push((byte >> i) & 1);
-            }
-        }
-        // Count runs
-        let runs = 1;
-        for (let i = 1; i < bits.length; i++) {
-            if (bits[i] !== bits[i - 1]) {
-                runs++;
-            }
-        }
-        // Expected number of runs
-        const n = bits.length;
-        const ones = bits.filter((bit) => bit === 1).length;
-        const expectedRuns = (2 * ones * (n - ones)) / n + 1;
-        const deviation = Math.abs(runs - expectedRuns) / expectedRuns;
-        const score = Math.max(0, 1 - deviation);
-        const passed = deviation < 0.2;
-        return { passed, score };
-    }
-    /**
-     * Frequency test - checks distribution of byte values
-     * @param data - Data to test
-     * @returns Test result
-     */
-    static frequencyTest(data) {
-        const frequency = new Array(256).fill(0);
-        for (const byte of data) {
-            frequency[byte]++;
-        }
-        const expected = data.length / 256;
-        let chiSquare = 0;
-        for (let i = 0; i < 256; i++) {
-            const observed = frequency[i];
-            chiSquare += Math.pow(observed - expected, 2) / expected;
-        }
-        // Normalize chi-square value
-        const normalizedChiSquare = chiSquare / (256 - 1);
-        const score = Math.max(0, 1 - normalizedChiSquare / 2);
-        const passed = normalizedChiSquare < 1.5;
-        return { passed, score };
-    }
-    /**
-     * Serial test - checks correlation between consecutive bytes
-     * @param data - Data to test
-     * @returns Test result
-     */
-    static serialTest(data) {
-        if (data.length < 2) {
-            return { passed: true, score: 1 };
-        }
-        const pairs = new Map();
-        for (let i = 0; i < data.length - 1; i++) {
-            const pair = `${data[i]}-${data[i + 1]}`;
-            pairs.set(pair, (pairs.get(pair) || 0) + 1);
-        }
-        const totalPairs = data.length - 1;
-        const expectedFreq = totalPairs / (256 * 256);
-        let chiSquare = 0;
-        // Check all possible pairs
-        for (let i = 0; i < 256; i++) {
-            for (let j = 0; j < 256; j++) {
-                const pair = `${i}-${j}`;
-                const observed = pairs.get(pair) || 0;
-                chiSquare +=
-                    Math.pow(observed - expectedFreq, 2) / expectedFreq;
-            }
-        }
-        const normalizedChiSquare = chiSquare / (256 * 256 - 1);
-        const score = Math.max(0, 1 - normalizedChiSquare / 2);
-        const passed = normalizedChiSquare < 1.5;
-        return { passed, score };
-    }
-    /**
-     * Estimate entropy rate of data
-     * @param data - Data to analyze
-     * @returns Entropy rate in bits per byte
-     */
-    static estimateEntropyRate(data) {
-        if (data.length === 0)
-            return 0;
-        // Use compression-based entropy estimation
-        const compressed = crypto.createHash("sha256").update(data).digest();
-        const compressionRatio = compressed.length / data.length;
-        // Estimate entropy based on compression
-        const estimatedEntropy = 8 * (1 - compressionRatio);
-        // Also calculate Shannon entropy for comparison
-        const frequency = new Map();
-        for (const byte of data) {
-            frequency.set(byte, (frequency.get(byte) || 0) + 1);
-        }
-        let shannonEntropy = 0;
-        const length = data.length;
-        for (const count of frequency.values()) {
-            const probability = count / length;
-            shannonEntropy -= probability * Math.log2(probability);
-        }
-        // Return the more conservative estimate
-        return Math.min(estimatedEntropy, shannonEntropy);
-    }
-    /**
-     * Generate entropy quality report
-     * @param data - Data to analyze
-     * @returns Comprehensive entropy report
-     */
-    static generateEntropyReport(data) {
-        const analysis = HashEntropy.analyzeHashEntropy(data);
-        const randomnessTests = HashEntropy.performRandomnessTests(data);
-        const entropyRate = HashEntropy.estimateEntropyRate(data);
-        const recommendations = [...analysis.recommendations];
-        // Add recommendations based on randomness tests
-        if (!randomnessTests.monobitTest.passed) {
-            recommendations.push("Data fails monobit test - check bit balance");
-        }
-        if (!randomnessTests.runsTest.passed) {
-            recommendations.push("Data fails runs test - check for patterns");
-        }
-        if (!randomnessTests.frequencyTest.passed) {
-            recommendations.push("Data fails frequency test - improve byte distribution");
-        }
-        if (!randomnessTests.serialTest.passed) {
-            recommendations.push("Data fails serial test - reduce correlation");
-        }
-        // Determine overall grade
-        const scores = [
-            analysis.shannonEntropy / 8, // Normalize to 0-1
-            analysis.randomnessScore,
-            randomnessTests.overallScore,
-            entropyRate / 8, // Normalize to 0-1
-        ];
-        const overallScore = scores.reduce((sum, score) => sum + score, 0) / scores.length;
-        let overallGrade;
-        if (overallScore > 0.9) {
-            overallGrade = "EXCELLENT";
-        }
-        else if (overallScore > 0.8) {
-            overallGrade = "GOOD";
-        }
-        else if (overallScore > 0.6) {
-            overallGrade = "FAIR";
-        }
-        else {
-            overallGrade = "POOR";
-        }
-        return {
-            analysis,
-            randomnessTests,
-            entropyRate,
-            recommendations: [...new Set(recommendations)], // Remove duplicates
-            overallGrade,
-        };
-    }
-}
-
-export { HashEntropy };
-//# sourceMappingURL=hash-entropy.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"hash-entropy.js","sources":["../../../../../../../mods/toolkit/src/core/hash/hash-entropy.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}