xypriss 1.0.1 → 1.1.0

package/dist/cjs/mods/security/src/core/hash.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var hashCore = require('./hash/hash-core.js');
+var hashTypes = require('./hash/hash-types.js');
+var hashUtils = require('./hash/hash-utils.js');
+var hashValidator = require('./hash/hash-validator.js');
+var hashSecurity = require('./hash/hash-security.js');
+var hashAdvanced = require('./hash/hash-advanced.js');
+var hashEntropy = require('./hash/hash-entropy.js');
+var hashAlgorithms = require('../algorithms/hash-algorithms.js');
+
+
+
+exports.Hash = hashCore.Hash;
+Object.defineProperty(exports, 'HashStrength', {
+	enumerable: true,
+	get: function () { return hashTypes.HashStrength; }
+});
+exports.HashUtils = hashUtils.HashUtils;
+exports.HashValidator = hashValidator.HashValidator;
+exports.HashSecurity = hashSecurity.HashSecurity;
+exports.HashAdvanced = hashAdvanced.HashAdvanced;
+exports.HashEntropy = hashEntropy.HashEntropy;
+exports.HashAlgorithms = hashAlgorithms.HashAlgorithms;
+//# sourceMappingURL=hash.js.map

package/dist/cjs/mods/security/src/core/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/mods/security/src/core/keys/algorithms/mods/Argon2Algo.js

@@ -0,0 +1,135 @@
+'use strict';
+
+var keysLogger = require('../../keys-logger.js');
+var keysTypes = require('../../keys-types.js');
+var keysUtils = require('../../keys-utils.js');
+var ScryptAlgo = require('./ScryptAlgo.js');
+
+/**
+ * Argon2 implementation with multiple backends
+ */
+class Argon2Algo {
+    /**
+     * Derive key using Argon2 with optimal backend selection
+     */
+    static derive(password, salt, iterations, keyLength, variant = "argon2id") {
+        const startTime = performance.now();
+        let backend;
+        let key;
+        let error;
+        try {
+            // Primary: Node.js argon2 library (if available)
+            if (this.canUseArgon2Library()) {
+                const result = this.deriveWithNodeLibrary(password, salt, iterations, keyLength, variant);
+                backend = keysTypes.AlgorithmBackend.EXTERNAL_LIBRARY;
+                key = result;
+                keysLogger.keyLogger.debug("Argon2", "Using Node.js argon2 library");
+            }
+            // Secondary: Browser argon2-browser (if available and has sync API)
+            else if (this.canUseBrowserArgon2()) {
+                const result = this.deriveWithBrowserLibrary(password, salt, iterations, keyLength, variant);
+                backend = keysTypes.AlgorithmBackend.EXTERNAL_LIBRARY;
+                key = result;
+                keysLogger.keyLogger.debug("Argon2", "Using browser argon2 library");
+            }
+            // Fallback: Scrypt with equivalent parameters
+            else {
+                keysLogger.keyLogger.warn("Argon2", "Argon2 not available, using Scrypt fallback");
+                const scryptCost = Math.min(18, Math.max(14, Math.floor(iterations / 2)));
+                const scryptResult = ScryptAlgo.ScryptAlgo.derive(password, salt, scryptCost, keyLength);
+                backend = keysTypes.AlgorithmBackend.PURE_JS;
+                key = scryptResult.key;
+            }
+        }
+        catch (err) {
+            error = err instanceof Error ? err.message : "Unknown error";
+            throw err;
+        }
+        finally {
+            const executionTime = performance.now() - startTime;
+            const algorithm = variant === "argon2i"
+                ? keysTypes.KeyDerivationAlgorithm.ARGON2I
+                : variant === "argon2d"
+                    ? keysTypes.KeyDerivationAlgorithm.ARGON2D
+                    : keysTypes.KeyDerivationAlgorithm.ARGON2ID;
+            const metrics = {
+                algorithm,
+                backend: backend,
+                executionTime,
+                memoryUsage: keysUtils.PerformanceUtils.estimateMemoryUsage(key),
+                iterations,
+                keyLength,
+                success: !error,
+                errorMessage: error,
+                timestamp: Date.now(),
+            };
+            keysLogger.keyLogger.logMetrics(metrics);
+            return { key: key, backend: backend, metrics };
+        }
+    }
+    static canUseArgon2Library() {
+        try {
+            if (typeof require === "function") {
+                const argon2 = require("argon2");
+                // Check if sync version is available (some versions have it)
+                return (typeof argon2.hashSync === "function" ||
+                    typeof argon2.hash === "function");
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    static canUseBrowserArgon2() {
+        try {
+            if (typeof window !== "undefined" &&
+                typeof require === "function") {
+                const argon2Browser = require("argon2-browser");
+                return typeof argon2Browser.hashSync === "function";
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    static deriveWithNodeLibrary(password, salt, iterations, keyLength, variant) {
+        const argon2 = require("argon2");
+        // Try sync version first if available
+        if (typeof argon2.hashSync === "function") {
+            const result = argon2.hashSync(Buffer.from(password), {
+                type: argon2[variant] || argon2.argon2id,
+                timeCost: iterations,
+                memoryCost: 4096,
+                parallelism: 1,
+                salt: Buffer.from(salt),
+                hashLength: keyLength,
+                raw: true,
+            });
+            return new Uint8Array(result);
+        }
+        // If no sync version, throw error to trigger fallback
+        throw new Error("Argon2 sync API not available");
+    }
+    static deriveWithBrowserLibrary(password, salt, iterations, keyLength, _variant) {
+        const argon2Browser = require("argon2-browser");
+        // Only use if synchronous API is available
+        if (typeof argon2Browser.hashSync === "function") {
+            const result = argon2Browser.hashSync({
+                pass: password,
+                salt: salt,
+                time: iterations,
+                mem: 4096,
+                parallelism: 1,
+                hashLen: keyLength,
+                type: argon2Browser.ArgonType.Argon2id,
+            });
+            return new Uint8Array(result.hash);
+        }
+        throw new Error("Browser Argon2 sync API not available");
+    }
+}
+
+exports.Argon2Algo = Argon2Algo;
+//# sourceMappingURL=Argon2Algo.js.map

package/dist/cjs/mods/security/src/core/keys/algorithms/mods/Argon2Algo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Argon2Algo.js","sources":["../../../../../../../../../mods/security/src/core/keys/algorithms/mods/Argon2Algo.ts"],"sourcesContent":[null],"names":["AlgorithmBackend","keyLogger","ScryptAlgo","KeyDerivationAlgorithm","PerformanceUtils"],"mappings":"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"}

package/dist/cjs/mods/security/src/core/keys/algorithms/mods/PBKDF2Algo.js

@@ -0,0 +1,293 @@
+'use strict';
+
+var keysLogger = require('../../keys-logger.js');
+var keysTypes = require('../../keys-types.js');
+var crypto = require('crypto');
+var keysUtils = require('../../keys-utils.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);
+
+/**
+ * High-performance PBKDF2 (Password-Based Key Derivation Function 2) implementation
+ * with intelligent backend selection and comprehensive error handling.
+ *
+ * This implementation provides optimal performance by automatically selecting
+ * the best available cryptographic backend in the following priority order:
+ * 1. Node.js native crypto (fastest, most secure)
+ * 2. External pbkdf2 library (good performance, widely compatible)
+ * 3. Pure JavaScript fallback (slowest, maximum compatibility)
+ *
+ * @example
+ * ```typescript
+ * const password = new TextEncoder().encode('mypassword');
+ * const salt = crypto.randomBytes(16);
+ * const result = PBKDF2Algo.derive(password, salt, 100000, 32, KeyDerivationHashFunction.SHA256);
+ * console.log('Derived key:', result.key);
+ * console.log('Backend used:', result.backend);
+ * ```
+ */
+class PBKDF2Algo {
+    /**
+     * Derives a cryptographic key from a password using PBKDF2 algorithm.
+     *
+     * This method automatically selects the optimal backend for maximum performance
+     * and provides detailed metrics about the derivation process. The implementation
+     * follows RFC 2898 specifications for PBKDF2.
+     *
+     * @param password - The input password as a Uint8Array
+     * @param salt - Cryptographic salt as a Uint8Array (recommended: 16+ bytes)
+     * @param iterations - Number of iterations (recommended: 100,000+ for passwords)
+     * @param keyLength - Desired output key length in bytes
+     * @param hashFunction - Hash function to use (SHA256 or SHA512)
+     *
+     * @returns Object containing:
+     *   - key: The derived key as Uint8Array
+     *   - backend: Which backend was used for derivation
+     *   - metrics: Performance and execution metrics
+     *
+     * @throws {Error} When all backends fail or invalid parameters are provided
+     *
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const result = PBKDF2Algo.derive(
+     *   new TextEncoder().encode('password123'),
+     *   crypto.randomBytes(16),
+     *   100000,
+     *   32,
+     *   KeyDerivationHashFunction.SHA256
+     * );
+     *
+     * // Check which backend was used
+     * if (result.backend === AlgorithmBackend.NODE_CRYPTO) {
+     *   console.log('Using fastest native implementation');
+     * }
+     * ```
+     */
+    static derive(password, salt, iterations, keyLength, hashFunction) {
+        // Input validation
+        this.validateInputs(password, salt, iterations, keyLength);
+        const startTime = performance.now();
+        let backend;
+        let key;
+        let error;
+        try {
+            // Try backends in order of performance preference
+            if (this.isNodeCryptoAvailable()) {
+                key = this.deriveWithNodeCrypto(password, salt, iterations, keyLength, hashFunction);
+                backend = keysTypes.AlgorithmBackend.NODE_CRYPTO;
+                keysLogger.keyLogger.debug("PBKDF2", "Using optimized Node.js crypto backend");
+            }
+            else if (this.isLibraryAvailable()) {
+                key = this.deriveWithLibrary(password, salt, iterations, keyLength, hashFunction);
+                backend = keysTypes.AlgorithmBackend.EXTERNAL_LIBRARY;
+                keysLogger.keyLogger.debug("PBKDF2", "Using external pbkdf2 library backend");
+            }
+            else {
+                // No synchronous implementation available
+                throw new Error("No secure PBKDF2 implementation available. " +
+                    "Please install Node.js crypto or pbkdf2 library for production use.");
+            }
+            return this.createSuccessResult(key, backend, startTime, iterations, keyLength);
+        }
+        catch (err) {
+            error =
+                err instanceof Error
+                    ? err.message
+                    : "Unknown PBKDF2 derivation error";
+            keysLogger.keyLogger.error("PBKDF2", `Derivation failed: ${error}`);
+            const metrics = this.createErrorMetrics(startTime, iterations, keyLength, error);
+            keysLogger.keyLogger.logMetrics(metrics);
+            throw new Error(`PBKDF2 derivation failed: ${error}`);
+        }
+    }
+    /**
+     * Validates input parameters for PBKDF2 derivation.
+     *
+     * @private
+     * @param password - Password to validate
+     * @param salt - Salt to validate
+     * @param iterations - Iteration count to validate
+     * @param keyLength - Key length to validate
+     * @throws {Error} When validation fails
+     */
+    static validateInputs(password, salt, iterations, keyLength) {
+        if (!password || password.length === 0) {
+            throw new Error("Password cannot be empty");
+        }
+        if (!salt || salt.length < 8) {
+            throw new Error("Salt must be at least 8 bytes long");
+        }
+        if (iterations < 1000) {
+            throw new Error("Iteration count must be at least 1000 for security");
+        }
+        if (keyLength < 1 || keyLength > 2048) {
+            throw new Error("Key length must be between 1 and 2048 bytes");
+        }
+    }
+    /**
+     * Checks if Node.js crypto module is available and functional.
+     * Uses caching to avoid repeated checks for better performance.
+     *
+     * @private
+     * @returns True if Node.js crypto is available
+     */
+    static isNodeCryptoAvailable() {
+        if (this.backendCache.nodeChecked) {
+            return this.backendCache.nodeAvailable;
+        }
+        try {
+            this.backendCache.nodeAvailable =
+                typeof crypto__namespace !== "undefined" &&
+                    typeof crypto__namespace.pbkdf2Sync === "function" &&
+                    typeof crypto__namespace.randomBytes === "function";
+        }
+        catch {
+            this.backendCache.nodeAvailable = false;
+        }
+        this.backendCache.nodeChecked = true;
+        return this.backendCache.nodeAvailable;
+    }
+    /**
+     * Checks if external pbkdf2 library is available.
+     * Uses caching to avoid repeated require() calls.
+     *
+     * @private
+     * @returns True if pbkdf2 library is available
+     */
+    static isLibraryAvailable() {
+        if (this.backendCache.libraryChecked) {
+            return this.backendCache.libraryAvailable;
+        }
+        try {
+            if (typeof require === "function") {
+                const pbkdf2Lib = require("pbkdf2");
+                this.backendCache.libraryAvailable =
+                    typeof pbkdf2Lib.pbkdf2Sync === "function";
+            }
+            else {
+                this.backendCache.libraryAvailable = false;
+            }
+        }
+        catch {
+            this.backendCache.libraryAvailable = false;
+        }
+        this.backendCache.libraryChecked = true;
+        return this.backendCache.libraryAvailable;
+    }
+    /**
+     * Performs PBKDF2 derivation using Node.js native crypto module.
+     * This is the fastest and most secure implementation.
+     *
+     * @private
+     * @param password - Input password
+     * @param salt - Cryptographic salt
+     * @param iterations - Iteration count
+     * @param keyLength - Output key length
+     * @param hashFunction - Hash function to use
+     * @returns Derived key as Uint8Array
+     */
+    static deriveWithNodeCrypto(password, salt, iterations, keyLength, hashFunction) {
+        const digest = hashFunction === keysTypes.KeyDerivationHashFunction.SHA512
+            ? "sha512"
+            : "sha256";
+        const result = crypto__namespace.pbkdf2Sync(Buffer.from(password), Buffer.from(salt), iterations, keyLength, digest);
+        return new Uint8Array(result);
+    }
+    /**
+     * Performs PBKDF2 derivation using external pbkdf2 library.
+     * Provides good performance with wide compatibility.
+     *
+     * @private
+     * @param password - Input password
+     * @param salt - Cryptographic salt
+     * @param iterations - Iteration count
+     * @param keyLength - Output key length
+     * @param hashFunction - Hash function to use
+     * @returns Derived key as Uint8Array
+     */
+    static deriveWithLibrary(password, salt, iterations, keyLength, hashFunction) {
+        const pbkdf2Lib = require("pbkdf2");
+        const digest = hashFunction === keysTypes.KeyDerivationHashFunction.SHA512
+            ? "sha512"
+            : "sha256";
+        const result = pbkdf2Lib.pbkdf2Sync(Buffer.from(password), Buffer.from(salt), iterations, keyLength, digest);
+        return new Uint8Array(result);
+    }
+    /**
+     * Creates a successful result object with metrics.
+     *
+     * @private
+     * @param key - Derived key
+     * @param backend - Backend used
+     * @param startTime - Operation start time
+     * @param iterations - Iteration count used
+     * @param keyLength - Key length generated
+     * @returns Complete result object
+     */
+    static createSuccessResult(key, backend, startTime, iterations, keyLength) {
+        const executionTime = performance.now() - startTime;
+        const metrics = {
+            algorithm: keysTypes.KeyDerivationAlgorithm.PBKDF2,
+            backend,
+            executionTime,
+            memoryUsage: keysUtils.PerformanceUtils.estimateMemoryUsage(key),
+            iterations,
+            keyLength,
+            success: true,
+            timestamp: Date.now(),
+        };
+        keysLogger.keyLogger.logMetrics(metrics);
+        return { key, backend, metrics };
+    }
+    /**
+     * Creates error metrics for failed operations.
+     *
+     * @private
+     * @param startTime - Operation start time
+     * @param iterations - Attempted iteration count
+     * @param keyLength - Attempted key length
+     * @param error - Error message
+     * @returns Error metrics object
+     */
+    static createErrorMetrics(startTime, iterations, keyLength, error) {
+        return {
+            algorithm: keysTypes.KeyDerivationAlgorithm.PBKDF2,
+            backend: keysTypes.AlgorithmBackend.PURE_JS, // Default for error case
+            executionTime: performance.now() - startTime,
+            memoryUsage: 0,
+            iterations,
+            keyLength,
+            success: false,
+            errorMessage: error,
+            timestamp: Date.now(),
+        };
+    }
+}
+/** Cache for backend availability to avoid repeated checks */
+PBKDF2Algo.backendCache = {
+    nodeChecked: false,
+    nodeAvailable: false,
+    libraryChecked: false,
+    libraryAvailable: false,
+};
+
+exports.PBKDF2Algo = PBKDF2Algo;
+//# sourceMappingURL=PBKDF2Algo.js.map

package/dist/cjs/mods/security/src/core/keys/algorithms/mods/PBKDF2Algo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PBKDF2Algo.js","sources":["../../../../../../../../../mods/security/src/core/keys/algorithms/mods/PBKDF2Algo.ts"],"sourcesContent":[null],"names":["AlgorithmBackend","keyLogger","crypto","KeyDerivationHashFunction","KeyDerivationAlgorithm","PerformanceUtils"],"mappings":"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"}