xypriss 1.0.0 → 1.0.1

package/dist/esm/mods/toolkit/src/core/keys.js

@@ -0,0 +1,134 @@
+import { OptimizedKeys } from './keys/keys-core.js';
+import './keys/keys-logger.js';
+import './keys/keys-types.js';
+import './keys/keys-utils.js';
+import 'crypto';
+import './keys/algorithms/mods/PBKDF2Algo.js';
+
+/**
+ * Legacy Keys implementation for key derivation and management.
+ * This class provides a backward-compatible interface for key derivation while leveraging
+ * the modern, optimized key derivation infrastructure. It serves as a facade to the {@link OptimizedKeys} class,
+ * simplifying interaction with cryptographic key operations and providing environment insights.
+ *
+ * @remarks
+ * - This class ensures compatibility with legacy systems while delegating core functionality to {@link OptimizedKeys}.
+ * - All methods are static, allowing direct usage without instantiation.
+ * - Designed to be thread-safe and efficient by reusing a singleton instance of {@link OptimizedKeys}.
+ *
+ * @public
+ */
+/**
+ * ### Cryptographic Key Management
+ *
+ * Advanced key generation, derivation, and management utilities for
+ * symmetric and asymmetric cryptographic operations.
+ *
+ * @example
+ * ```typescript
+ * import { Keys } from "xypriss-security";
+ *
+ * // Generate encryption key
+ * const encryptionKey = Keys.generateEncryptionKey(256);
+ *
+ * // Derive key from password
+ * const derivedKey = await Keys.deriveKey("password", "salt");
+ * ```
+ */
+class Keys {
+    /**
+     * Derives a cryptographic key from the provided input using specified options.
+     * This method delegates to the optimized key derivation system, ensuring high performance
+     * and adherence to cryptographic best practices.
+     *
+     * @param input - The input data for key derivation, either a password (string) or raw bytes (Uint8Array).
+     * @param options - Optional configuration for key derivation, including algorithm, iterations, and other parameters.
+     *                  If omitted, default values are applied based on the underlying {@link OptimizedKeys} implementation.
+     * @returns A hexadecimal string representing the derived cryptographic key.
+     *
+     * @example
+     * ```typescript
+     * const key = Keys.deriveKey('myPassword', { algorithm: 'PBKDF2', iterations: 100000 });
+     * console.log(key); // Outputs: "a1b2c3d4e5f6..."
+     * ```
+     *
+     * @remarks
+     * - Throws an invalid input error if the input format is invalid or unsupported.
+     * - The output length depends on the algorithm and options specified.
+     * - For security, ensure the input is securely handled to prevent leakage.
+     *
+     * @public
+     */
+    static deriveKey(input, options = {}) {
+        return OptimizedKeys.getInstance().deriveKey(input, options);
+    }
+    /**
+     * Retrieves performance metrics for key derivation operations.
+     * Offers detailed insights into the efficiency and resource usage of the underlying
+     * optimized key derivation system.
+     *
+     * @returns An object containing performance metrics, such as derivation time (ms) and memory usage (MB).
+     *
+     * @example
+     * ```typescript
+     * const metrics = Keys.getMetrics();
+     * console.log(metrics); // Outputs: { derivationTimeMs: 10, memoryUsedMb: 2.5, operationsCount: 100, ... }
+     * ```
+     *
+     * @remarks
+     * - Metrics are aggregated from the {@link OptimizedKeys} instance and may include vendor-specific data.
+     * - Useful for debugging and optimizing key derivation processes in performance-critical applications.
+     *
+     * @public
+     */
+    static getMetrics() {
+        return OptimizedKeys.getInstance().getMetrics();
+    }
+    /**
+     * Retrieves information about the current runtime environment.
+     * Includes details about such the as platform, supported cryptographic algorithms,
+     * and other environment-specific data relevant to key derivation.
+     *
+     * @returns An object containing environment-specific information, such as platform type and cryptographic capabilities.
+     *
+     * @example
+     * ```typescript
+     * const envInfo = Keys.getEnvironmentInfo();
+     * console.log('envInfo); // Outputs: ' { platform: 'Node.js', cryptoSupport: ['PBKDF2', 'Argon2'], version: '18.x', ... }
+     * ```
+     *
+     * @remarks
+     * - The exact structure of the returned object may vary depending on the runtime environment.
+     * - Useful for feature detection and compatibility checks in cross-platform applications.
+     *
+     * @public
+     */
+    static getEnvironmentInfo() {
+        return OptimizedKeys.getInstance().getEnvironmentInfo();
+    }
+    /**
+     * Recommends an optimal key derivation algorithm based on the current runtime environment.
+     * Evaluates the environment to suggest a secure algorithm and performant algorithm, prioritizing security.
+     * security.
+     *
+     * @returns A string indicating the recommended key derivation algorithm (e.g., 'PBKDF2', 'Argon2').
+     *
+     * @example
+     * ```typescript
+     * const algorithm = Keys.getRecommendedAlgorithm();
+     * console.log(algorithm); // Outputs: 'Argon2'
+     * ```
+     *
+     * @remarks
+     * - The recommendation is based on factors like CPU architecture, memory availability, and cryptographic library support.
+     * - The recommended algorithm may differ across environments (e.g., browser vs. server).
+     *
+     * @public
+     */
+    static getRecommendedAlgorithm() {
+        return OptimizedKeys.getInstance().getRecommendedAlgorithm();
+    }
+}
+
+export { Keys };
+//# sourceMappingURL=keys.js.map

package/dist/esm/mods/toolkit/src/core/keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.js","sources":["../../../../../../mods/toolkit/src/core/keys.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;AAAA;;;;;;;;;;;;AAYG;AAKH;;;;;;;;;;;;;;;;AAgBG;MACU,IAAI,CAAA;AACb;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,IAAA,OAAO,SAAS,CACnB,KAA0B,EAC1B,UAAgC,EAAE,EAAA;QAElC,OAAO,aAAa,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;KAChE;AAED;;;;;;;;;;;;;;;;;;AAkBG;AACI,IAAA,OAAO,UAAU,GAAA;AACpB,QAAA,OAAO,aAAa,CAAC,WAAW,EAAE,CAAC,UAAU,EAAE,CAAC;KACnD;AAED;;;;;;;;;;;;;;;;;;AAkBG;AACI,IAAA,OAAO,kBAAkB,GAAA;AAC5B,QAAA,OAAO,aAAa,CAAC,WAAW,EAAE,CAAC,kBAAkB,EAAE,CAAC;KAC3D;AAED;;;;;;;;;;;;;;;;;;AAkBG;AACI,IAAA,OAAO,uBAAuB,GAAA;AACjC,QAAA,OAAO,aAAa,CAAC,WAAW,EAAE,CAAC,uBAAuB,EAAE,CAAC;KAChE;AACJ;;;;"}

package/dist/esm/mods/toolkit/src/core/password/index.js

@@ -0,0 +1,110 @@
+import { PasswordManager } from './password-core.js';
+import '../random/random-types.js';
+import '../random/random-sources.js';
+import 'crypto';
+import 'nehonix-uri-processor';
+import '../../utils/memory/index.js';
+import '../../types.js';
+export { PasswordAlgorithm, PasswordSecurityLevel } from './password-types.js';
+import '../hash/hash-core.js';
+import '../hash/hash-types.js';
+import '../hash/hash-security.js';
+import '../hash/hash-advanced.js';
+import '../../algorithms/hash-algorithms.js';
+import 'argon2';
+import 'child_process';
+import '../../types/secure-memory.js';
+import 'https';
+import '../../components/runtime-verification.js';
+import '../../components/tamper-evident-logging.js';
+
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) NEHONIX INC. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ * -------------------------------------------------------------------------------------------
+ */
+/**
+ * XyPrissSecurity Password Management Module => FPMM
+ *
+ * Modular, military-grade password management system
+ *
+ * @example
+ * ```typescript
+ * import { PasswordManager } from "xypriss-security/core/password";
+ *
+ * // Create password manager instance
+ * const pm = PasswordManager.getInstance();
+ *
+ * // Hash a password
+ * const hash = await pm.hash("mySecurePassword123!");
+ *
+ * // Verify a password
+ * const result = await pm.verify("mySecurePassword123!", hash);
+ * console.log(result.isValid); // true
+ *
+ * // Generate secure password
+ * const generated = pm.generatePassword({ length: 16, minStrengthScore: 90 });
+ * console.log(generated.password);
+ *
+ * // Migrate from bcrypt
+ * const migration = await pm.migrate("password", bcryptHash);
+ * if (migration.migrated) {
+ *     console.log("Successfully migrated to XyPrissSecurity!");
+ * }
+ * ```
+ */
+PasswordManager.getInstance();
+/**
+ * Get default password policy
+ */
+function getDefaultPasswordPolicy() {
+    return {
+        minLength: 8,
+        maxLength: 128,
+        requireUppercase: true,
+        requireLowercase: true,
+        requireNumbers: true,
+        requireSymbols: true,
+        minStrengthScore: 70,
+        forbiddenPatterns: [
+            /^[0-9]+$/, // All numbers
+            /^[a-zA-Z]+$/, // All letters
+            /^(.)\1{2,}$/, // Repeated characters
+            /^(qwerty|asdfgh|zxcvbn)/i, // Keyboard patterns
+            /^(password|admin|user)/i, // Common words
+        ],
+        forbiddenWords: [
+            "password",
+            "admin",
+            "user",
+            "login",
+            "welcome",
+            "123456",
+            "qwerty",
+            "abc123",
+            "password123",
+        ],
+    };
+}
+/**
+ * Get recommended security configuration
+ */
+function getRecommendedConfig() {
+    return {
+        defaultAlgorithm: "argon2id",
+        defaultSecurityLevel: "high",
+        timingSafeVerification: true,
+        secureMemoryWipe: true,
+        enableMigration: true,
+        policy: getDefaultPasswordPolicy(),
+    };
+}
+// ===== DEFAULT INSTANCE =====
+/**
+ * Default password manager instance
+ * Ready to use out of the box
+ */
+PasswordManager.getInstance(getRecommendedConfig());
+
+export { PasswordManager, getDefaultPasswordPolicy, getRecommendedConfig };
+//# sourceMappingURL=index.js.map

package/dist/esm/mods/toolkit/src/core/password/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../mods/toolkit/src/core/password/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;;;;AAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;AAgBe,eAAe,CAAC,WAAW,GAAG;AAyFhD;;AAEG;SACa,wBAAwB,GAAA;IACpC,OAAO;AACH,QAAA,SAAS,EAAE,CAAC;AACZ,QAAA,SAAS,EAAE,GAAG;AACd,QAAA,gBAAgB,EAAE,IAAI;AACtB,QAAA,gBAAgB,EAAE,IAAI;AACtB,QAAA,cAAc,EAAE,IAAI;AACpB,QAAA,cAAc,EAAE,IAAI;AACpB,QAAA,gBAAgB,EAAE,EAAE;AACpB,QAAA,iBAAiB,EAAE;AACf,YAAA,UAAU;AACV,YAAA,aAAa;AACb,YAAA,aAAa;AACb,YAAA,0BAA0B;AAC1B,YAAA,yBAAyB;AAC5B,SAAA;AACD,QAAA,cAAc,EAAE;YACZ,UAAU;YACV,OAAO;YACP,MAAM;YACN,OAAO;YACP,SAAS;YACT,QAAQ;YACR,QAAQ;YACR,QAAQ;YACR,aAAa;AAChB,SAAA;KACJ,CAAC;AACN,CAAC;AAED;;AAEG;SACa,oBAAoB,GAAA;IAChC,OAAO;AACH,QAAA,gBAAgB,EAAE,UAAiB;AACnC,QAAA,oBAAoB,EAAE,MAAa;AACnC,QAAA,sBAAsB,EAAE,IAAI;AAC5B,QAAA,gBAAgB,EAAE,IAAI;AACtB,QAAA,eAAe,EAAE,IAAI;QACrB,MAAM,EAAE,wBAAwB,EAAE;KACrC,CAAC;AACN,CAAC;AA8HD;AAEA;;;AAGG;AACmC,eAAe,CAAC,WAAW,CAC7D,oBAAoB,EAAE;;;;"}

package/dist/esm/mods/toolkit/src/core/password/password-algorithms.js

@@ -0,0 +1,395 @@
+import { Hash } from '../hash/hash-core.js';
+import { HashStrength } from '../hash/hash-types.js';
+import 'crypto';
+import '../hash/hash-security.js';
+import '../hash/hash-advanced.js';
+import '../../algorithms/hash-algorithms.js';
+import { SecureRandom } from '../random/random-core.js';
+import '../random/random-types.js';
+import '../random/random-sources.js';
+import 'nehonix-uri-processor';
+import '../../utils/memory/index.js';
+import { HashAlgorithm } from '../../types.js';
+import { constantTimeEqual } from '../../components/side-channel.js';
+import 'argon2';
+import 'child_process';
+import '../../types/secure-memory.js';
+import 'https';
+import '../../components/runtime-verification.js';
+import '../../components/tamper-evident-logging.js';
+import { PasswordAlgorithm } from './password-types.js';
+
+/**
+ * 🔐 Password Algorithms Module
+ *
+ * Implements various password hashing algorithms with security optimizations
+ */
+/**
+ * Password hashing algorithms implementation
+ */
+class PasswordAlgorithms {
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = config;
+    }
+    /**
+     * Hash password using specified algorithm
+     */
+    async hash(password, salt, options) {
+        switch (options.algorithm) {
+            case PasswordAlgorithm.ARGON2ID:
+                return this.hashWithArgon2(password, salt, options, "id");
+            case PasswordAlgorithm.ARGON2I:
+                return this.hashWithArgon2(password, salt, options, "i");
+            case PasswordAlgorithm.ARGON2D:
+                return this.hashWithArgon2(password, salt, options, "d");
+            case PasswordAlgorithm.SCRYPT:
+                return this.hashWithScrypt(password, salt, options);
+            case PasswordAlgorithm.PBKDF2_SHA512:
+                return this.hashWithPBKDF2(password, salt, options);
+            case PasswordAlgorithm.BCRYPT_PLUS:
+                return this.hashWithBcryptPlus(password, salt, options);
+            case PasswordAlgorithm.MILITARY:
+                return this.hashWithMilitary(password, salt, options);
+            default:
+                throw new Error(`Unsupported algorithm: ${options.algorithm}`);
+        }
+    }
+    /**
+     * Verify password using specified algorithm
+     */
+    async verify(password, hash, salt, metadata) {
+        const options = {
+            algorithm: metadata.algorithm,
+            securityLevel: metadata.securityLevel,
+            iterations: metadata.iterations,
+            memorySize: metadata.memorySize,
+            parallelism: metadata.parallelism,
+            saltLength: metadata.saltLength,
+        };
+        const computedHash = await this.hash(password, salt, options);
+        // Use constant-time comparison to prevent timing attacks
+        return constantTimeEqual(hash, computedHash);
+    }
+    /**
+     * Hash with Argon2 (recommended)
+     */
+    async hashWithArgon2(password, salt, options, variant) {
+        // Try to use native Argon2 implementation
+        try {
+            const argon2 = await import('argon2').catch(() => null);
+            if (argon2) {
+                const argon2Options = {
+                    type: variant === "i"
+                        ? argon2.argon2i
+                        : variant === "d"
+                            ? argon2.argon2d
+                            : argon2.argon2id,
+                    memoryCost: options.memorySize || 65536,
+                    timeCost: Math.floor((options.iterations || 100000) / 1000),
+                    parallelism: options.parallelism || 4,
+                    salt: Buffer.from(salt),
+                    hashLength: 32,
+                };
+                const fullHash = await argon2.hash(password, argon2Options);
+                // Extract just the hash part from the full Argon2 format
+                return this.extractHashValue(fullHash);
+            }
+        }
+        catch (error) {
+            // Fall back to custom implementation
+        }
+        // Fallback: Use PBKDF2 with enhanced security
+        return this.hashWithEnhancedPBKDF2(password, salt, options, `argon2${variant}-fallback`);
+    }
+    /**
+     * Hash with scrypt
+     */
+    async hashWithScrypt(password, salt, options) {
+        try {
+            // Use Node.js built-in crypto.scrypt
+            const crypto = await import('crypto');
+            const scryptOptions = {
+                N: Math.pow(2, 14), // CPU/memory cost (16384 - more reasonable)
+                r: 8, // Block size
+                p: options.parallelism || 1,
+            };
+            // Use promisified scrypt
+            const result = await new Promise((resolve, reject) => {
+                crypto.scrypt(password, Buffer.from(salt), 32, scryptOptions, (err, derivedKey) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(derivedKey);
+                });
+            });
+            return result.toString("hex");
+        }
+        catch (error) {
+            // Fall back to enhanced PBKDF2
+        }
+        return this.hashWithEnhancedPBKDF2(password, salt, options, "scrypt-fallback");
+    }
+    /**
+     * Hash with PBKDF2-SHA512
+     */
+    async hashWithPBKDF2(password, salt, options) {
+        const iterations = options.iterations || 100000;
+        // Use XyPrissSecurity Hash module for PBKDF2
+        const hash = Hash.createSecureHash(password, salt, {
+            algorithm: HashAlgorithm.PBKDF2,
+            iterations,
+            outputFormat: "hex",
+            strength: HashStrength.MILITARY,
+            memoryHard: false, // Explicitly disable memory-hard hashing
+            quantumResistant: false, // Explicitly disable quantum-resistant hashing
+            timingSafe: false, // Explicitly disable timing-safe hashing
+        });
+        // Extract just the hash part using our helper method
+        return this.extractHashValue(hash);
+    }
+    /**
+     * Enhanced PBKDF2 with multiple rounds and algorithms
+     */
+    async hashWithEnhancedPBKDF2(password, salt, options, prefix = "enhanced") {
+        const iterations = options.iterations || 100000;
+        // First round: PBKDF2-SHA512
+        let round1 = Hash.createSecureHash(password, salt, {
+            algorithm: HashAlgorithm.PBKDF2,
+            iterations: Math.floor(iterations / 3),
+            outputFormat: "hex",
+            memoryHard: false,
+            quantumResistant: false,
+            timingSafe: false,
+        });
+        // Extract just the hash using our helper method
+        round1 = this.extractHashValue(round1);
+        // Second round: SHA3-512
+        let round2 = Hash.createSecureHash(round1, salt, {
+            algorithm: HashAlgorithm.SHA3_512,
+            iterations: Math.floor(iterations / 3),
+            outputFormat: "hex",
+            memoryHard: false,
+            quantumResistant: false,
+            timingSafe: false,
+        });
+        // Extract just the hash using our helper method
+        round2 = this.extractHashValue(round2);
+        // Third round: BLAKE3
+        let finalHash = Hash.createSecureHash(round2, salt, {
+            algorithm: HashAlgorithm.BLAKE3,
+            iterations: Math.floor(iterations / 3),
+            outputFormat: "hex",
+            memoryHard: false,
+            quantumResistant: false,
+            timingSafe: false,
+        });
+        // Extract just the hash using our helper method
+        finalHash = this.extractHashValue(finalHash);
+        return `${prefix}:${finalHash}`;
+    }
+    /**
+     * Enhanced bcrypt with additional security layers
+     */
+    async hashWithBcryptPlus(password, salt, options) {
+        try {
+            const bcrypt = await import('bcrypt').catch(() => null);
+            if (bcrypt) {
+                // First layer: Standard bcrypt
+                const rounds = Math.min(15, Math.max(10, Math.floor((options.iterations || 100000) / 10000)));
+                const bcryptHash = await bcrypt.hash(password, rounds);
+                // Second layer: PBKDF2 on bcrypt result
+                let enhancedHash = Hash.createSecureHash(bcryptHash, salt, {
+                    algorithm: HashAlgorithm.PBKDF2,
+                    iterations: 50000,
+                    outputFormat: "hex",
+                    memoryHard: false,
+                    quantumResistant: false,
+                    timingSafe: false,
+                });
+                // Extract just the hash using our helper method
+                enhancedHash = this.extractHashValue(enhancedHash);
+                return `bcrypt-plus:${enhancedHash}`;
+            }
+        }
+        catch (error) {
+            // Fall back to enhanced PBKDF2
+        }
+        return this.hashWithEnhancedPBKDF2(password, salt, options, "bcrypt-plus-fallback");
+    }
+    /**
+     * Military-grade multi-layer hashing
+     */
+    async hashWithMilitary(password, salt, options) {
+        const iterations = options.iterations || 200000;
+        // Layer 1: Key stretching with PBKDF2-SHA512
+        let layer1 = Hash.createSecureHash(password, salt, {
+            algorithm: HashAlgorithm.PBKDF2,
+            iterations: Math.floor(iterations / 4),
+            outputFormat: "hex",
+            memoryHard: false,
+            quantumResistant: false,
+            timingSafe: false,
+        });
+        // Extract just the hash using our helper method
+        layer1 = this.extractHashValue(layer1);
+        // Layer 2: Memory-hard function simulation
+        let layer2 = layer1;
+        for (let i = 0; i < 1000; i++) {
+            const tempSalt = SecureRandom.generateSalt(32);
+            let tempHash = Hash.createSecureHash(layer2, tempSalt, {
+                algorithm: HashAlgorithm.SHA3_512,
+                outputFormat: "hex",
+                memoryHard: false,
+                quantumResistant: false,
+                timingSafe: false,
+            });
+            // Extract just the hash using our helper method
+            layer2 = this.extractHashValue(tempHash);
+        }
+        // Layer 3: BLAKE3 with high iterations
+        let layer3 = Hash.createSecureHash(layer2, salt, {
+            algorithm: HashAlgorithm.BLAKE3,
+            iterations: Math.floor(iterations / 4),
+            outputFormat: "hex",
+            memoryHard: false,
+            quantumResistant: false,
+            timingSafe: false,
+        });
+        // Extract just the hash using our helper method
+        layer3 = this.extractHashValue(layer3);
+        // Layer 4: Final hardening with SHA3-512
+        let finalHash = Hash.createSecureHash(layer3, salt, {
+            algorithm: HashAlgorithm.SHA3_512,
+            iterations: Math.floor(iterations / 4),
+            outputFormat: "hex",
+            strength: HashStrength.MILITARY,
+            memoryHard: false,
+            quantumResistant: false,
+            timingSafe: false,
+        });
+        // Extract just the hash using our helper method
+        finalHash = this.extractHashValue(finalHash);
+        return `military:${finalHash}`;
+    }
+    // ===== PRIVATE HELPER METHODS =====
+    /**
+     * Extract just the hash value from complex hash formats
+     */
+    extractHashValue(hashResult) {
+        // Handle Argon2 format: $argon2id$v=19$m=65536,t=3,p=4$salt$hash
+        if (hashResult.startsWith("$argon2")) {
+            const parts = hashResult.split("$");
+            if (parts.length >= 6) {
+                return parts[5]; // The actual hash is the last part
+            }
+        }
+        // Handle PBKDF2 format: $pbkdf2$rounds$salt$hash
+        if (hashResult.startsWith("$pbkdf2")) {
+            const parts = hashResult.split("$");
+            if (parts.length >= 5) {
+                return parts[4]; // The actual hash
+            }
+        }
+        // Handle bcrypt format: $2b$rounds$salthash (extract hash part)
+        if (hashResult.startsWith("$2")) {
+            const parts = hashResult.split("$");
+            if (parts.length >= 4) {
+                const saltAndHash = parts[3];
+                if (saltAndHash.length > 22) {
+                    return saltAndHash.substring(22); // bcrypt hash after 22-char salt
+                }
+            }
+        }
+        // Handle scrypt format: $scrypt$N$r$p$salt$hash
+        if (hashResult.startsWith("$scrypt")) {
+            const parts = hashResult.split("$");
+            if (parts.length >= 7) {
+                return parts[6]; // The actual hash
+            }
+        }
+        // Handle any other $ delimited format - take the last part
+        if (hashResult.includes("$")) {
+            const parts = hashResult.split("$");
+            return parts[parts.length - 1];
+        }
+        // If no special format, return as-is
+        return hashResult;
+    }
+    /**
+     * Get algorithm-specific default options
+     */
+    getAlgorithmDefaults(algorithm) {
+        switch (algorithm) {
+            case PasswordAlgorithm.ARGON2ID:
+            case PasswordAlgorithm.ARGON2I:
+            case PasswordAlgorithm.ARGON2D:
+                return {
+                    iterations: 3,
+                    memorySize: 65536, // 64MB
+                    parallelism: 4,
+                    saltLength: 32,
+                };
+            case PasswordAlgorithm.SCRYPT:
+                return {
+                    iterations: 32768, // N parameter
+                    memorySize: 8, // r parameter
+                    parallelism: 1, // p parameter
+                    saltLength: 32,
+                };
+            case PasswordAlgorithm.PBKDF2_SHA512:
+                return {
+                    iterations: 100000,
+                    saltLength: 32,
+                };
+            case PasswordAlgorithm.BCRYPT_PLUS:
+                return {
+                    iterations: 120000, // Equivalent to bcrypt rounds + PBKDF2
+                    saltLength: 32,
+                };
+            case PasswordAlgorithm.MILITARY:
+                return {
+                    iterations: 200000,
+                    memorySize: 131072, // 128MB equivalent
+                    parallelism: 8,
+                    saltLength: 64,
+                };
+            default:
+                return {
+                    iterations: 100000,
+                    saltLength: 32,
+                };
+        }
+    }
+    /**
+     * Estimate hashing time for algorithm
+     */
+    estimateHashingTime(algorithm, options) {
+        // Rough estimates in milliseconds
+        switch (algorithm) {
+            case PasswordAlgorithm.ARGON2ID:
+            case PasswordAlgorithm.ARGON2I:
+            case PasswordAlgorithm.ARGON2D:
+                return ((options.memorySize || 65536) / 1000 +
+                    (options.iterations || 3) * 100);
+            case PasswordAlgorithm.SCRYPT:
+                return (options.iterations || 32768) / 100;
+            case PasswordAlgorithm.PBKDF2_SHA512:
+                return (options.iterations || 100000) / 1000;
+            case PasswordAlgorithm.BCRYPT_PLUS:
+                return (options.iterations || 120000) / 500;
+            case PasswordAlgorithm.MILITARY:
+                return (options.iterations || 200000) / 200;
+            default:
+                return 100; // Default estimate
+        }
+    }
+}
+
+export { PasswordAlgorithms };
+//# sourceMappingURL=password-algorithms.js.map

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

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