xypriss 1.0.0 → 1.1.0

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

@@ -0,0 +1,328 @@
+'use strict';
+
+var crypto = require('crypto');
+var hashTypes = require('./hash-types.js');
+var encoding = require('../../utils/encoding.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);
+
+/**
+ * Hash utilities - Common utility functions for hash operations
+ */
+class HashUtils {
+    /**
+     * Format hash output in the specified format
+     * @param data - Data to format
+     * @param format - Output format
+     * @returns Formatted output
+     */
+    static formatOutput(data, format = "hex") {
+        const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+        switch (format) {
+            case "hex":
+                return encoding.bufferToHex(buffer);
+            case "base64":
+                return encoding.bufferToBase64(buffer);
+            case "base58":
+                return encoding.bufferToBase58(buffer);
+            case "binary":
+                return encoding.bufferToBinary(buffer);
+            case "base64url":
+                return encoding.bufferToBase64Url(buffer);
+            case "buffer":
+                return buffer;
+            default:
+                return encoding.bufferToHex(buffer);
+        }
+    }
+    /**
+     * Get strength-based configuration
+     * @param strength - Hash strength level
+     * @returns Configuration object
+     */
+    static getStrengthConfiguration(strength) {
+        switch (strength) {
+            case hashTypes.HashStrength.WEAK:
+                return {
+                    minIterations: 1000,
+                    saltLength: 8,
+                    algorithm: "sha256",
+                };
+            case hashTypes.HashStrength.FAIR:
+                return {
+                    minIterations: 10000,
+                    saltLength: 16,
+                    algorithm: "sha256",
+                };
+            case hashTypes.HashStrength.GOOD:
+                return {
+                    minIterations: 50000,
+                    saltLength: 32,
+                    algorithm: "sha512",
+                };
+            case hashTypes.HashStrength.STRONG:
+                return {
+                    minIterations: 100000,
+                    saltLength: 64,
+                    algorithm: "sha512",
+                };
+            case hashTypes.HashStrength.MILITARY:
+                return {
+                    minIterations: 500000,
+                    saltLength: 128,
+                    algorithm: "blake3",
+                };
+            default:
+                return {
+                    minIterations: 50000,
+                    saltLength: 32,
+                    algorithm: "sha512",
+                };
+        }
+    }
+    /**
+     * Get Argon2 configuration based on strength
+     * @param strength - Hash strength level
+     * @returns Argon2 configuration
+     */
+    static getArgon2Configuration(strength) {
+        switch (strength) {
+            case hashTypes.HashStrength.WEAK:
+                return {
+                    minIterations: 0,
+                    saltLength: 16,
+                    memoryCost: 1024, // 1 MB
+                    timeCost: 1,
+                    parallelism: 1,
+                    hashLength: 32,
+                    fallbackIterations: 10000,
+                };
+            case hashTypes.HashStrength.FAIR:
+                return {
+                    minIterations: 0,
+                    saltLength: 16,
+                    memoryCost: 4096, // 4 MB
+                    timeCost: 2,
+                    parallelism: 1,
+                    hashLength: 32,
+                    fallbackIterations: 50000,
+                };
+            case hashTypes.HashStrength.GOOD:
+                return {
+                    minIterations: 0,
+                    saltLength: 32,
+                    memoryCost: 16384, // 16 MB
+                    timeCost: 3,
+                    parallelism: 2,
+                    hashLength: 32,
+                    fallbackIterations: 100000,
+                };
+            case hashTypes.HashStrength.STRONG:
+                return {
+                    minIterations: 0,
+                    saltLength: 64,
+                    memoryCost: 32768, // 32 MB
+                    timeCost: 4,
+                    parallelism: 4,
+                    hashLength: 64,
+                    fallbackIterations: 200000,
+                };
+            case hashTypes.HashStrength.MILITARY:
+                return {
+                    minIterations: 0,
+                    saltLength: 128,
+                    memoryCost: 65536, // 64 MB
+                    timeCost: 5,
+                    parallelism: 8,
+                    hashLength: 64,
+                    fallbackIterations: 500000,
+                };
+            default:
+                return {
+                    minIterations: 0,
+                    saltLength: 32,
+                    memoryCost: 16384,
+                    timeCost: 3,
+                    parallelism: 2,
+                    hashLength: 32,
+                    fallbackIterations: 100000,
+                };
+        }
+    }
+    /**
+     * Get scrypt configuration based on strength
+     * @param strength - Hash strength level
+     * @returns Scrypt configuration
+     */
+    static getScryptConfiguration(strength) {
+        switch (strength) {
+            case hashTypes.HashStrength.WEAK:
+                return { N: 4096, r: 4, p: 1 };
+            case hashTypes.HashStrength.FAIR:
+                return { N: 8192, r: 6, p: 1 };
+            case hashTypes.HashStrength.GOOD:
+                return { N: 16384, r: 8, p: 1 };
+            case hashTypes.HashStrength.STRONG:
+                return { N: 32768, r: 8, p: 2 };
+            case hashTypes.HashStrength.MILITARY:
+                return { N: 65536, r: 8, p: 4 };
+            default:
+                return { N: 16384, r: 8, p: 1 };
+        }
+    }
+    /**
+     * Perform secure memory wipe
+     * @param input - Input to wipe
+     * @param salt - Salt to wipe
+     * @param pepper - Pepper to wipe
+     */
+    static performSecureWipe(input, salt, pepper) {
+        try {
+            // Wipe input if it's a buffer
+            if (Buffer.isBuffer(input)) {
+                input.fill(0);
+            }
+            else if (input instanceof Uint8Array) {
+                input.fill(0);
+            }
+            // Wipe salt if provided and is a buffer
+            if (salt) {
+                if (Buffer.isBuffer(salt)) {
+                    salt.fill(0);
+                }
+                else if (salt instanceof Uint8Array) {
+                    salt.fill(0);
+                }
+            }
+            // Wipe pepper if provided and is a buffer
+            if (pepper) {
+                if (Buffer.isBuffer(pepper)) {
+                    pepper.fill(0);
+                }
+                else if (pepper instanceof Uint8Array) {
+                    pepper.fill(0);
+                }
+            }
+        }
+        catch (error) {
+            console.warn("Secure wipe failed:", error);
+        }
+    }
+    /**
+     * Validate hash algorithm
+     * @param algorithm - Algorithm to validate
+     * @returns True if valid
+     */
+    static isValidAlgorithm(algorithm) {
+        const validAlgorithms = [
+            "sha256",
+            "sha512",
+            "sha3-256",
+            "sha3-512",
+            "blake3",
+            "blake2b",
+            "blake2s",
+            "md5",
+            "sha1", // Included for compatibility but not recommended
+        ];
+        return validAlgorithms.includes(algorithm.toLowerCase());
+    }
+    /**
+     * Get algorithm security level
+     * @param algorithm - Algorithm to check
+     * @returns Security level
+     */
+    static getAlgorithmSecurityLevel(algorithm) {
+        const algo = algorithm.toLowerCase();
+        if (["md5", "sha1"].includes(algo)) {
+            return "LOW";
+        }
+        else if (["sha256"].includes(algo)) {
+            return "MEDIUM";
+        }
+        else if (["sha512", "sha3-256", "sha3-512"].includes(algo)) {
+            return "HIGH";
+        }
+        else if (["blake3", "blake2b", "blake2s"].includes(algo)) {
+            return "MILITARY";
+        }
+        return "MEDIUM"; // Default
+    }
+    /**
+     * Convert string or Uint8Array to Buffer
+     * @param input - Input to convert
+     * @returns Buffer
+     */
+    static toBuffer(input) {
+        if (Buffer.isBuffer(input)) {
+            return input;
+        }
+        else if (input instanceof Uint8Array) {
+            // Handle EnhancedUint8Array and regular Uint8Array
+            if ("toUint8Array" in input &&
+                typeof input.toUint8Array === "function") {
+                // EnhancedUint8Array - use its toUint8Array method
+                return Buffer.from(input.toUint8Array());
+            }
+            else {
+                // Regular Uint8Array
+                return Buffer.from(input);
+            }
+        }
+        else {
+            return Buffer.from(input, "utf8");
+        }
+    }
+    /**
+     * Generate random salt with specified length
+     * @param length - Salt length in bytes
+     * @returns Random salt buffer
+     */
+    static generateRandomSalt(length) {
+        return crypto__namespace.randomBytes(length);
+    }
+    /**
+     * Combine multiple buffers securely
+     * @param buffers - Buffers to combine
+     * @returns Combined buffer
+     */
+    static combineBuffers(buffers) {
+        return Buffer.concat(buffers);
+    }
+    /**
+     * XOR two buffers of equal length
+     * @param a - First buffer
+     * @param b - Second buffer
+     * @returns XORed result
+     */
+    static xorBuffers(a, b) {
+        if (a.length !== b.length) {
+            throw new Error("Buffers must be of equal length for XOR operation");
+        }
+        const result = Buffer.alloc(a.length);
+        for (let i = 0; i < a.length; i++) {
+            result[i] = a[i] ^ b[i];
+        }
+        return result;
+    }
+}
+
+exports.HashUtils = HashUtils;
+//# sourceMappingURL=hash-utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash-utils.js","sources":["../../../../../../../mods/security/src/core/hash/hash-utils.ts"],"sourcesContent":[null],"names":["bufferToHex","bufferToBase64","bufferToBase58","bufferToBinary","bufferToBase64Url","HashStrength","crypto"],"mappings":"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"}

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

@@ -0,0 +1,312 @@
+'use strict';
+
+/**
+ * Hash validator - Input validation and security checks
+ */
+class HashValidator {
+    /**
+     * Validate hash input for security
+     * @param input - Input to validate
+     * @param options - Validation options
+     */
+    static validateHashInput(input, options) {
+        // Check input length (allow empty strings for edge cases)
+        if (typeof input === "string" && input.length === 0) {
+            console.warn("Warning: Hashing empty string");
+        }
+        if (input instanceof Uint8Array && input.length === 0) {
+            console.warn("Warning: Hashing empty array");
+        }
+        // Check for suspicious patterns
+        if (typeof input === "string") {
+            // Check for null bytes
+            if (input.includes("\0")) {
+                throw new Error("Input contains null bytes");
+            }
+            // Check for extremely long inputs (potential DoS)
+            if (input.length > 1000000) {
+                // 1MB limit
+                throw new Error("Input too large (max 1MB)");
+            }
+            // Check for common weak patterns
+            if (HashValidator.hasWeakPatterns(input)) {
+                console.warn("Input contains weak patterns that may reduce security");
+            }
+        }
+        // Validate Uint8Array input
+        if (input instanceof Uint8Array) {
+            if (input.length > 10000000) {
+                // 10MB limit for binary data
+                throw new Error("Binary input too large (max 10MB)");
+            }
+        }
+        // Validate options
+        HashValidator.validateOptions(options);
+    }
+    /**
+     * Check for weak patterns in input
+     * @param input - String input to check
+     * @returns True if weak patterns found
+     */
+    static hasWeakPatterns(input) {
+        // Check for repeated characters
+        if (/(.)\1{10,}/.test(input)) {
+            return true;
+        }
+        // Check for simple sequences
+        if (/012345|123456|abcdef|qwerty/i.test(input)) {
+            return true;
+        }
+        // Check for common weak passwords
+        const weakPatterns = [
+            /^password/i,
+            /^123456/,
+            /^admin/i,
+            /^test/i,
+            /^guest/i,
+        ];
+        return weakPatterns.some((pattern) => pattern.test(input));
+    }
+    /**
+     * Validate hash options
+     * @param options - Options to validate
+     */
+    static validateOptions(options) {
+        // Validate iterations
+        if (options.iterations !== undefined) {
+            if (options.iterations < 1) {
+                throw new Error("Iterations must be at least 1");
+            }
+            if (options.iterations > 10000000) {
+                throw new Error("Iterations too high (max 10,000,000)");
+            }
+        }
+        // Validate algorithm
+        if (options.algorithm) {
+            const validAlgorithms = [
+                "sha256",
+                "sha512",
+                "sha3-256",
+                "sha3-512",
+                "blake3",
+                "blake2b",
+                "blake2s",
+                "pbkdf2",
+            ];
+            if (!validAlgorithms.includes(options.algorithm)) {
+                throw new Error(`Unsupported algorithm: ${options.algorithm}`);
+            }
+        }
+        // Validate output format
+        if (options.outputFormat) {
+            const validFormats = [
+                "hex",
+                "base64",
+                "base58",
+                "binary",
+                "base64url",
+                "buffer",
+            ];
+            if (!validFormats.includes(options.outputFormat)) {
+                throw new Error(`Unsupported output format: ${options.outputFormat}`);
+            }
+        }
+        // Validate salt
+        if (options.salt) {
+            if (typeof options.salt === "string" && options.salt.length === 0) {
+                throw new Error("Salt cannot be empty string");
+            }
+            if (options.salt instanceof Uint8Array &&
+                options.salt.length === 0) {
+                throw new Error("Salt cannot be empty array");
+            }
+        }
+        // Validate pepper
+        if (options.pepper) {
+            if (typeof options.pepper === "string" &&
+                options.pepper.length === 0) {
+                throw new Error("Pepper cannot be empty string");
+            }
+            if (options.pepper instanceof Uint8Array &&
+                options.pepper.length === 0) {
+                throw new Error("Pepper cannot be empty array");
+            }
+        }
+    }
+    /**
+     * Validate password strength
+     * @param password - Password to validate
+     * @returns Validation result
+     */
+    static validatePasswordStrength(password) {
+        const issues = [];
+        const recommendations = [];
+        let score = 0;
+        // Length check
+        if (password.length < 8) {
+            issues.push("Password too short (minimum 8 characters)");
+        }
+        else if (password.length < 12) {
+            issues.push("Password should be at least 12 characters");
+            score += 10;
+        }
+        else {
+            score += 25;
+        }
+        // Character variety
+        const hasLower = /[a-z]/.test(password);
+        const hasUpper = /[A-Z]/.test(password);
+        const hasDigit = /\d/.test(password);
+        const hasSpecial = /[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/.test(password);
+        if (hasLower)
+            score += 15;
+        else
+            issues.push("Missing lowercase letters");
+        if (hasUpper)
+            score += 15;
+        else
+            issues.push("Missing uppercase letters");
+        if (hasDigit)
+            score += 15;
+        else
+            issues.push("Missing numbers");
+        if (hasSpecial)
+            score += 15;
+        else
+            issues.push("Missing special characters");
+        // Common patterns
+        if (/(.)\1{2,}/.test(password)) {
+            issues.push("Contains repeated characters");
+            score -= 10;
+        }
+        // Only flag sequential patterns if they're significant (4+ chars)
+        if (/1234|abcd|qwer/i.test(password)) {
+            issues.push("Contains sequential patterns");
+            score -= 15;
+        }
+        // Dictionary words (basic check)
+        const commonWords = [
+            "password",
+            "admin",
+            "user",
+            "test",
+            "guest",
+            "login",
+        ];
+        if (commonWords.some((word) => password.toLowerCase().includes(word))) {
+            issues.push("Contains common dictionary words");
+            score -= 20;
+        }
+        // Generate recommendations
+        if (score < 60) {
+            recommendations.push("Use a longer password with mixed character types");
+        }
+        if (!hasSpecial) {
+            recommendations.push("Add special characters");
+        }
+        if (password.length < 12) {
+            recommendations.push("Use at least 12 characters");
+        }
+        if (issues.some((issue) => issue.includes("repeated") || issue.includes("sequential"))) {
+            recommendations.push("Avoid repeated characters and sequential patterns");
+        }
+        return {
+            isSecure: score >= 70 &&
+                issues.filter((issue) => !issue.includes("should be"))
+                    .length === 0,
+            score: Math.max(0, Math.min(100, score)),
+            issues,
+            recommendations,
+        };
+    }
+    /**
+     * Enhanced timing-safe string comparison
+     * @param a - First string/buffer
+     * @param b - Second string/buffer
+     * @returns True if equal
+     */
+    static timingSafeEqual(a, b) {
+        // Convert inputs to buffers
+        const bufferA = Buffer.isBuffer(a)
+            ? a
+            : a instanceof Uint8Array
+                ? Buffer.from(a)
+                : Buffer.from(a, "utf8");
+        const bufferB = Buffer.isBuffer(b)
+            ? b
+            : b instanceof Uint8Array
+                ? Buffer.from(b)
+                : Buffer.from(b, "utf8");
+        // Use Node.js timing-safe comparison if lengths match
+        if (bufferA.length === bufferB.length) {
+            try {
+                return require("crypto").timingSafeEqual(bufferA, bufferB);
+            }
+            catch (error) {
+                // Fallback to manual timing-safe comparison
+                return HashValidator.manualTimingSafeEqual(bufferA, bufferB);
+            }
+        }
+        // For different lengths, still do timing-safe comparison
+        return HashValidator.manualTimingSafeEqual(bufferA, bufferB);
+    }
+    /**
+     * Manual timing-safe comparison implementation
+     */
+    static manualTimingSafeEqual(a, b) {
+        let result = 0;
+        const maxLength = Math.max(a.length, b.length);
+        // Always compare the same number of bytes
+        for (let i = 0; i < maxLength; i++) {
+            const byteA = i < a.length ? a[i] : 0;
+            const byteB = i < b.length ? b[i] : 0;
+            result |= byteA ^ byteB;
+        }
+        // Also compare lengths in a timing-safe way
+        result |= a.length ^ b.length;
+        return result === 0;
+    }
+    /**
+     * Validate salt quality
+     * @param salt - Salt to validate
+     * @returns Validation result
+     */
+    static validateSalt(salt) {
+        const issues = [];
+        const recommendations = [];
+        // Convert to buffer for analysis
+        const saltBuffer = Buffer.isBuffer(salt)
+            ? salt
+            : salt instanceof Uint8Array
+                ? Buffer.from(salt)
+                : Buffer.from(salt, "base64");
+        // Check length
+        if (saltBuffer.length < 16) {
+            issues.push("Salt too short (minimum 16 bytes recommended)");
+            recommendations.push("Use at least 16 bytes for salt");
+        }
+        if (saltBuffer.length < 32) {
+            recommendations.push("Consider using 32+ bytes for stronger security");
+        }
+        // Check for patterns (basic entropy check)
+        const uniqueBytes = new Set(saltBuffer);
+        const entropyRatio = uniqueBytes.size / saltBuffer.length;
+        if (entropyRatio < 0.5) {
+            issues.push("Salt has low entropy (too many repeated bytes)");
+            recommendations.push("Use cryptographically secure random salt generation");
+        }
+        // Check for all zeros or all same value
+        if (uniqueBytes.size === 1) {
+            issues.push("Salt contains only one unique value");
+            recommendations.push("Generate random salt using secure random number generator");
+        }
+        return {
+            isValid: issues.length === 0,
+            issues,
+            recommendations,
+        };
+    }
+}
+
+exports.HashValidator = HashValidator;
+//# sourceMappingURL=hash-validator.js.map

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

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