xypriss-security/dist/cjs/components/fortified-function/core/mods/security-manager.js

XyPriss Security is an advanced JavaScript security library designed for enterprise applications. It provides military-grade encryption, secure data structures, quantum-resistant cryptography, and comprehensive security utilities for modern web applicatio

'use strict';

var secureMemory = require('../../../secure-memory.js');
var secureStringCore = require('../../../secure-string/core/secure-string-core.js');
require('crypto');
require('../../../secure-string/advanced/entropy-analyzer.js');
require('../../../secure-string/advanced/quantum-safe.js');
require('../../../secure-string/advanced/performance-monitor.js');
var ArrayCryptoHandler = require('../../../secure-array/crypto/ArrayCryptoHandler.js');
var events = require('events');
var utils = require('../../utils/utils.js');

/**
 * Security Manager for Fortified Function Core
 * Handles encryption, parameter security, and stack trace protection
 */
class SecurityManager extends events.EventEmitter {
    constructor(options) {
        super();
        this.options = options;
        this.cryptoHandler = new ArrayCryptoHandler.ArrayCryptoHandler(`xypriss.func.${Date.now()}`);
    }
    /**
     * Encrypt sensitive parameters for secure storage
     */
    async encryptParameters(context, args) {
        const { secureParameters } = this.options;
        for (let i = 0; i < args.length; i++) {
            const shouldEncrypt = secureParameters.includes(i) ||
                secureParameters.includes(`param${i}`);
            if (shouldEncrypt && args[i] != null) {
                try {
                    // Convert to secure string and hash for security
                    const secureString = new secureStringCore.SecureString(String(args[i]));
                    const encrypted = await secureString.hash("SHA-256", "hex");
                    context.encryptedParameters.set(`param${i}`, encrypted);
                    // Store in secure buffer for memory management
                    const buffer = secureMemory.SecureBuffer.from(String(args[i]));
                    context.secureBuffers.set(`param${i}`, buffer);
                    context.auditEntry.securityFlags.push(`param${i}_encrypted`);
                    this.emit("parameter_encrypted", { parameter: i });
                }
                catch (error) {
                    this.emit("encryption_error", { parameter: i, error });
                }
            }
        }
    }
    /**
     * Execute function with stack trace protection
     */
    async executeWithStackProtection(originalFunction, args) {
        if (!this.options.stackTraceProtection) {
            return await originalFunction(...args);
        }
        try {
            return await originalFunction(...args);
        }
        catch (error) {
            // Sanitize stack trace to remove sensitive parameter information
            if (error instanceof Error && error.stack) {
                error.stack = utils.FortifiedUtils.sanitizeStackTrace(error.stack);
            }
            throw error;
        }
    }
    /**
     * Generate cache key for memoization
     */
    async generateCacheKey(args) {
        const serialized = JSON.stringify(args);
        const secureString = new secureStringCore.SecureString(serialized);
        try {
            return (await secureString.hash("SHA-256", "hex"));
        }
        finally {
            secureString.destroy();
        }
    }
    /**
     * Generate hash of parameters for audit logging
     */
    async hashParameters(args) {
        const serialized = utils.FortifiedUtils.serializeArgsForHash(args);
        const secureString = new secureStringCore.SecureString(serialized);
        try {
            return (await secureString.hash("SHA-256", "hex"));
        }
        finally {
            secureString.destroy();
        }
    }
    /**
     * Clean up security resources
     */
    destroy() {
        this.removeAllListeners();
    }
}

exports.SecurityManager = SecurityManager;
//# sourceMappingURL=security-manager.js.map