xypriss 1.0.0 → 1.0.1

package/dist/cjs/mods/toolkit/src/core/keys/algorithms/mods/ScryptAlgo.js

@@ -0,0 +1,317 @@
+'use strict';
+
+var keysLogger = require('../../keys-logger.js');
+var keysTypes = require('../../keys-types.js');
+var crypto = require('crypto');
+var PBKDF2Algo = require('./PBKDF2Algo.js');
+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);
+
+/**
+ * Scrypt key derivation algorithm implementation with multiple backend support.
+ *
+ * This class provides a robust Scrypt implementation that automatically selects
+ * the best available backend for optimal performance:
+ * 1. Node.js crypto (fastest, native implementation)
+ * 2. scrypt-js library (JavaScript implementation)
+ * 3. PBKDF2 fallback (when Scrypt is unavailable)
+ *
+ * @example
+ * ```typescript
+ * const password = new TextEncoder().encode('mypassword');
+ * const salt = crypto.randomBytes(32);
+ * const result = await ScryptAlgo.derive(password, salt, 14, 32);
+ * console.log('Derived key:', result.key);
+ * console.log('Backend used:', result.backend);
+ * ```
+ */
+class ScryptAlgo {
+    /**
+     * Derives a key using the Scrypt algorithm with automatic backend selection.
+     *
+     * This method automatically selects the most appropriate backend based on
+     * the runtime environment and available libraries. It provides comprehensive
+     * metrics and error handling for production use.
+     *
+     * @param password - The password to derive the key from
+     * @param salt - Cryptographic salt (should be at least 16 bytes)
+     * @param cost - Cost parameter (N = 2^cost). Recommended: 14-20 for production
+     * @param keyLength - Desired length of the derived key in bytes
+     * @returns Promise containing the derived key, backend used, and performance metrics
+     *
+     * @throws {Error} When all backends fail or invalid parameters are provided
+     *
+     * @example
+     * ```typescript
+     * // High security (slow)
+     * const highSec = await ScryptAlgo.derive(password, salt, 16, 32);
+     *
+     * // Balanced (recommended)
+     * const balanced = await ScryptAlgo.derive(password, salt, 14, 32);
+     *
+     * // Fast (for testing only)
+     * const fast = await ScryptAlgo.derive(password, salt, 10, 32);
+     * ```
+     */
+    static async asyncDerive(password, salt, cost, keyLength) {
+        // Input validation
+        this.validateInputs(password, salt, cost, keyLength);
+        const startTime = performance.now();
+        const N = Math.pow(2, cost);
+        const r = 8; // Standard block size factor
+        const p = 1; // Standard parallelization factor
+        let backend;
+        let key;
+        let error;
+        try {
+            // Primary: Node.js crypto (fastest, native implementation)
+            if (this.canUseNodeCrypto()) {
+                key = await this.deriveWithNodeCrypto(password, salt, N, r, p, keyLength);
+                backend = keysTypes.AlgorithmBackend.NODE_CRYPTO;
+                keysLogger.keyLogger.debug("Scrypt", "Using Node.js crypto backend", {
+                    N,
+                    r,
+                    p,
+                    keyLength,
+                });
+            }
+            // Secondary: scrypt-js library (JavaScript implementation)
+            else if (await this.canUseScryptLibrary()) {
+                key = await this.deriveWithLibrary(password, salt, N, r, p, keyLength);
+                backend = keysTypes.AlgorithmBackend.EXTERNAL_LIBRARY;
+                keysLogger.keyLogger.debug("Scrypt", "Using scrypt-js library", {
+                    N,
+                    r,
+                    p,
+                    keyLength,
+                });
+            }
+            // Fallback: PBKDF2 with equivalent security parameters
+            else {
+                keysLogger.keyLogger.warn("Scrypt", "Scrypt unavailable, using PBKDF2 fallback");
+                const equivalentIterations = this.calculateEquivalentPBKDF2Iterations(N, r, p);
+                const pbkdf2Result = await PBKDF2Algo.PBKDF2Algo.derive(password, salt, equivalentIterations, keyLength, keysTypes.KeyDerivationHashFunction.SHA512);
+                backend = keysTypes.AlgorithmBackend.PURE_JS;
+                key = pbkdf2Result.key;
+            }
+        }
+        catch (err) {
+            error = err instanceof Error ? err.message : "Unknown scrypt error";
+            keysLogger.keyLogger.error("Scrypt", "Key derivation failed", {
+                error,
+                cost,
+                keyLength,
+            });
+            throw new Error(`Scrypt key derivation failed: ${error}`);
+        }
+        const executionTime = performance.now() - startTime;
+        const metrics = {
+            algorithm: keysTypes.KeyDerivationAlgorithm.SCRYPT,
+            backend,
+            executionTime,
+            memoryUsage: keysUtils.PerformanceUtils.estimateMemoryUsage(key),
+            iterations: N,
+            keyLength,
+            success: !error,
+            errorMessage: error,
+            timestamp: Date.now(),
+        };
+        keysLogger.keyLogger.logMetrics(metrics);
+        return { key, backend, metrics };
+    }
+    /**
+     * Synchronous version of derive() for backward compatibility.
+     *
+     * **Deprecated**: Use the async version for better performance and error handling.
+     * This method is provided for backward compatibility but may block the event loop.
+     *
+     * @param password - The password to derive the key from
+     * @param salt - Cryptographic salt
+     * @param cost - Cost parameter (N = 2^cost)
+     * @param keyLength - Desired length of the derived key in bytes
+     * @returns Object containing the derived key, backend used, and performance metrics
+     *
+     * @deprecated Use the async derive() method instead
+     */
+    static derive(password, salt, cost, keyLength) {
+        // For backward compatibility, we'll use a synchronous approach
+        // but log a deprecation warning
+        keysLogger.keyLogger.warn("Scrypt", "Using deprecated synchronous derive method. Consider upgrading to async version.");
+        this.validateInputs(password, salt, cost, keyLength);
+        const startTime = performance.now();
+        const N = Math.pow(2, cost);
+        const r = 8;
+        const p = 1;
+        let backend;
+        let key;
+        let error;
+        try {
+            if (this.canUseNodeCrypto()) {
+                const result = crypto__namespace.scryptSync(Buffer.from(password), Buffer.from(salt), keyLength, { N, r, p });
+                backend = keysTypes.AlgorithmBackend.NODE_CRYPTO;
+                key = new Uint8Array(result);
+            }
+            else {
+                // Fallback to PBKDF2 for sync operation
+                keysLogger.keyLogger.warn("Scrypt", "Node crypto unavailable, using PBKDF2 fallback");
+                const equivalentIterations = this.calculateEquivalentPBKDF2Iterations(N, r, p);
+                const pbkdf2Result = PBKDF2Algo.PBKDF2Algo.derive(password, salt, equivalentIterations, keyLength, keysTypes.KeyDerivationHashFunction.SHA512);
+                backend = keysTypes.AlgorithmBackend.PURE_JS;
+                key = pbkdf2Result.key;
+            }
+        }
+        catch (err) {
+            error = err instanceof Error ? err.message : "Unknown error";
+            throw new Error(`Scrypt key derivation failed: ${error}`);
+        }
+        const executionTime = performance.now() - startTime;
+        const metrics = {
+            algorithm: keysTypes.KeyDerivationAlgorithm.SCRYPT,
+            backend,
+            executionTime,
+            memoryUsage: keysUtils.PerformanceUtils.estimateMemoryUsage(key),
+            iterations: N,
+            keyLength,
+            success: !error,
+            errorMessage: error,
+            timestamp: Date.now(),
+        };
+        keysLogger.keyLogger.logMetrics(metrics);
+        return { key, backend, metrics };
+    }
+    /**
+     * Validates input parameters for the Scrypt algorithm.
+     *
+     * @private
+     * @param password - Password to validate
+     * @param salt - Salt to validate
+     * @param cost - Cost parameter to validate
+     * @param keyLength - Key length to validate
+     * @throws {Error} When parameters are invalid
+     */
+    static validateInputs(password, salt, cost, keyLength) {
+        if (!password || password.length === 0) {
+            throw new Error("Password cannot be empty");
+        }
+        if (!salt || salt.length < 16) {
+            throw new Error("Salt must be at least 16 bytes");
+        }
+        if (cost < 1 || cost > 31) {
+            throw new Error("Cost parameter must be between 1 and 31");
+        }
+        if (keyLength < 1 || keyLength > 1024) {
+            throw new Error("Key length must be between 1 and 1024 bytes");
+        }
+    }
+    /**
+     * Derives key using Node.js native crypto implementation.
+     *
+     * @private
+     * @param password - Password bytes
+     * @param salt - Salt bytes
+     * @param N - Cost parameter
+     * @param r - Block size factor
+     * @param p - Parallelization factor
+     * @param keyLength - Desired key length
+     * @returns Promise resolving to derived key
+     */
+    static async deriveWithNodeCrypto(password, salt, N, r, p, keyLength) {
+        return new Promise((resolve, reject) => {
+            crypto__namespace.scrypt(Buffer.from(password), Buffer.from(salt), keyLength, { N, r, p }, (err, result) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(new Uint8Array(result));
+                }
+            });
+        });
+    }
+    /**
+     * Derives key using the scrypt-js library.
+     *
+     * @private
+     * @param password - Password bytes
+     * @param salt - Salt bytes
+     * @param N - Cost parameter
+     * @param r - Block size factor
+     * @param p - Parallelization factor
+     * @param keyLength - Desired key length
+     * @returns Promise resolving to derived key
+     */
+    static async deriveWithLibrary(password, salt, N, r, p, keyLength) {
+        const scryptJs = await import('scrypt-js');
+        return scryptJs.scrypt(password, salt, N, r, p, keyLength);
+    }
+    /**
+     * Calculates equivalent PBKDF2 iterations for similar security level.
+     *
+     * This is an approximation based on computational complexity analysis.
+     * The actual security depends on many factors including hardware characteristics.
+     *
+     * @private
+     * @param N - Scrypt cost parameter
+     * @param r - Scrypt block size factor
+     * @param p - Scrypt parallelization factor
+     * @returns Equivalent PBKDF2 iteration count
+     */
+    static calculateEquivalentPBKDF2Iterations(N, r, p) {
+        // Conservative approximation: Scrypt's memory-hard property makes it
+        // roughly equivalent to PBKDF2 with significantly more iterations
+        const baseIterations = N * r * p;
+        const securityMultiplier = 10; // Conservative estimate
+        return Math.min(1000000, baseIterations * securityMultiplier);
+    }
+    /**
+     * Checks if Node.js crypto scrypt is available.
+     *
+     * @private
+     * @returns True if Node.js crypto scrypt is available
+     */
+    static canUseNodeCrypto() {
+        try {
+            return (typeof crypto__namespace !== "undefined" &&
+                typeof crypto__namespace.scrypt === "function" &&
+                typeof crypto__namespace.scryptSync === "function");
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Checks if scrypt-js library is available.
+     *
+     * @private
+     * @returns Promise resolving to true if scrypt-js is available
+     */
+    static async canUseScryptLibrary() {
+        try {
+            await import('scrypt-js');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+
+exports.ScryptAlgo = ScryptAlgo;
+//# sourceMappingURL=ScryptAlgo.js.map

package/dist/cjs/mods/toolkit/src/core/keys/algorithms/mods/ScryptAlgo.js.map

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

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

@@ -0,0 +1,201 @@
+'use strict';
+
+var keysTypes = require('./keys-types.js');
+var keysLogger = require('./keys-logger.js');
+var keysUtils = require('./keys-utils.js');
+var Argon2Algo = require('./algorithms/mods/Argon2Algo.js');
+var PBKDF2Algo = require('./algorithms/mods/PBKDF2Algo.js');
+var ScryptAlgo = require('./algorithms/mods/ScryptAlgo.js');
+var stats = require('../../utils/stats.js');
+var randomCore = require('../random/random-core.js');
+require('../random/random-types.js');
+require('crypto');
+var constants = require('../../utils/constants.js');
+require('../random/random-sources.js');
+require('nehonix-uri-processor');
+require('../../utils/memory/index.js');
+require('../../types.js');
+
+/**
+ * Key Derivation Core
+ * Main orchestrator for the modular key derivation system
+ */
+/**
+ * Optimized Keys class with modular architecture
+ * Maintains backward compatibility while providing enhanced performance
+ */
+class OptimizedKeys {
+    constructor() {
+        this.environmentInfo = keysUtils.EnvironmentDetector.detect();
+        this.metricsCache = [];
+        keysLogger.keyLogger.info("Core", "Optimized Keys system initialized", {
+            environment: this.environmentInfo.type,
+            capabilities: this.environmentInfo.capabilities,
+        });
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance() {
+        if (!OptimizedKeys.instance) {
+            OptimizedKeys.instance = new OptimizedKeys();
+        }
+        return OptimizedKeys.instance;
+    }
+    /**
+     * Derive a key from a password or other input (backward compatible)
+     * @param input - The input to derive a key from
+     * @param options - Key derivation options
+     * @returns The derived key as a hex string
+     */
+    deriveKey(input, options = {}) {
+        const result = this.deriveKeyExtended(input, options);
+        return result.key;
+    }
+    /**
+     * Derive a key with extended options and metadata
+     * @param input - The input to derive a key from
+     * @param options - Extended key derivation options
+     * @returns Complete derivation result with metadata
+     */
+    deriveKeyExtended(input, options = {}) {
+        const startTime = Date.now();
+        // Validate and normalize inputs
+        const algorithm = keysUtils.ValidationUtils.validateAlgorithm(options.algorithm || "pbkdf2");
+        const iterations = keysUtils.ValidationUtils.validateIterations(options.iterations || this.getDefaultIterations(algorithm));
+        const keyLength = keysUtils.ValidationUtils.validateKeyLength(options.keyLength || constants.SECURITY_DEFAULTS.KEY_LENGTH);
+        const hashFunction = keysUtils.ValidationUtils.validateHashFunction(options.hashFunction || "sha256");
+        // Convert input to bytes
+        const inputBytes = keysUtils.ConversionUtils.toUint8Array(input);
+        // Generate or validate salt
+        let saltBytes;
+        if (options.salt) {
+            saltBytes = keysUtils.ValidationUtils.validateSalt(options.salt);
+        }
+        else {
+            saltBytes = randomCore.SecureRandom.getRandomBytes(16);
+        }
+        keysLogger.keyLogger.logAlgorithmSelection(algorithm, keysTypes.AlgorithmBackend.NODE_CRYPTO, // Will be updated by implementation
+        "User specified or default selection");
+        // Derive the key using the appropriate algorithm
+        let derivationResult;
+        try {
+            switch (algorithm) {
+                case keysTypes.KeyDerivationAlgorithm.PBKDF2:
+                    derivationResult = PBKDF2Algo.PBKDF2Algo.derive(inputBytes, saltBytes, iterations, keyLength, hashFunction);
+                    break;
+                case keysTypes.KeyDerivationAlgorithm.SCRYPT:
+                    const scryptCost = this.iterationsToScryptCost(iterations);
+                    derivationResult = ScryptAlgo.ScryptAlgo.derive(inputBytes, saltBytes, scryptCost, keyLength);
+                    break;
+                case keysTypes.KeyDerivationAlgorithm.ARGON2:
+                case keysTypes.KeyDerivationAlgorithm.ARGON2ID:
+                    derivationResult = Argon2Algo.Argon2Algo.derive(inputBytes, saltBytes, iterations, keyLength, "argon2id");
+                    break;
+                case keysTypes.KeyDerivationAlgorithm.ARGON2I:
+                    derivationResult = Argon2Algo.Argon2Algo.derive(inputBytes, saltBytes, iterations, keyLength, "argon2i");
+                    break;
+                case keysTypes.KeyDerivationAlgorithm.ARGON2D:
+                    derivationResult = Argon2Algo.Argon2Algo.derive(inputBytes, saltBytes, iterations, keyLength, "argon2d");
+                    break;
+                default:
+                    throw new Error(`Unsupported algorithm: ${algorithm}`);
+            }
+        }
+        catch (error) {
+            keysLogger.keyLogger.error("Core", "Key derivation failed", error);
+            throw error;
+        }
+        // Convert result to hex
+        const hexKey = keysUtils.ConversionUtils.toHexString(derivationResult.key);
+        // Secure memory cleanup
+        if (options.secureWipe !== false) {
+            keysUtils.ConversionUtils.secureWipe(derivationResult.key);
+            keysUtils.ConversionUtils.secureWipe(inputBytes);
+        }
+        // Track statistics
+        const endTime = Date.now();
+        stats.StatsTracker.getInstance().trackKeyDerivation(endTime - startTime, keyLength * 8 // Entropy bits
+        );
+        // Cache metrics
+        this.metricsCache.push(derivationResult.metrics);
+        if (this.metricsCache.length > 100) {
+            this.metricsCache.shift(); // Keep only recent metrics
+        }
+        const result = {
+            key: hexKey,
+            algorithm,
+            backend: derivationResult.backend,
+            metrics: derivationResult.metrics,
+            salt: saltBytes,
+            iterations,
+        };
+        keysLogger.keyLogger.info("Core", "Key derivation completed successfully", {
+            algorithm,
+            backend: derivationResult.backend,
+            executionTime: `${derivationResult.metrics.executionTime}ms`,
+        });
+        return result;
+    }
+    /**
+     * Get default iterations for an algorithm
+     */
+    getDefaultIterations(algorithm) {
+        switch (algorithm) {
+            case keysTypes.KeyDerivationAlgorithm.PBKDF2:
+                return keysUtils.ALGORITHM_DEFAULTS.PBKDF2.iterations;
+            case keysTypes.KeyDerivationAlgorithm.SCRYPT:
+                return Math.pow(2, keysUtils.ALGORITHM_DEFAULTS.SCRYPT.cost);
+            case keysTypes.KeyDerivationAlgorithm.ARGON2:
+            case keysTypes.KeyDerivationAlgorithm.ARGON2ID:
+            case keysTypes.KeyDerivationAlgorithm.ARGON2I:
+            case keysTypes.KeyDerivationAlgorithm.ARGON2D:
+                return keysUtils.ALGORITHM_DEFAULTS.ARGON2.timeCost;
+            default:
+                return constants.SECURITY_DEFAULTS.PBKDF2_ITERATIONS;
+        }
+    }
+    /**
+     * Convert iterations to scrypt cost parameter
+     */
+    iterationsToScryptCost(iterations) {
+        // Convert iterations to scrypt N parameter (power of 2)
+        const cost = Math.log2(iterations);
+        return Math.max(10, Math.min(20, Math.round(cost)));
+    }
+    /**
+     * Get performance metrics
+     */
+    getMetrics() {
+        return this.metricsCache.slice();
+    }
+    /**
+     * Get environment information
+     */
+    getEnvironmentInfo() {
+        return this.environmentInfo;
+    }
+    /**
+     * Clear metrics cache
+     */
+    clearMetrics() {
+        this.metricsCache.length = 0;
+    }
+    /**
+     * Get algorithm recommendations based on environment
+     */
+    getRecommendedAlgorithm() {
+        if (this.environmentInfo.capabilities.argon2) {
+            return keysTypes.KeyDerivationAlgorithm.ARGON2ID;
+        }
+        else if (this.environmentInfo.capabilities.scrypt) {
+            return keysTypes.KeyDerivationAlgorithm.SCRYPT;
+        }
+        else {
+            return keysTypes.KeyDerivationAlgorithm.PBKDF2;
+        }
+    }
+}
+
+exports.OptimizedKeys = OptimizedKeys;
+//# sourceMappingURL=keys-core.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keys-core.js","sources":["../../../../../../../mods/toolkit/src/core/keys/keys-core.ts"],"sourcesContent":[null],"names":["EnvironmentDetector","keyLogger","ValidationUtils","SECURITY_DEFAULTS","ConversionUtils","SecureRandom","AlgorithmBackend","KeyDerivationAlgorithm","PBKDF2Algo","ScryptAlgo","Argon2Algo","StatsTracker","ALGORITHM_DEFAULTS"],"mappings":"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"}