src/security/redos-protector.js

const { ReDoSError, SECURITY_CONFIG } = require('./security-config');
const vm = require('vm'); // Zero-dependency VM sandbox

/**
 * ReDoSProtector - Protects against Regular Expression Denial of Service attacks
 * Updated to use VM sandbox instead of setTimeout for better security
 */
class ReDoSProtector {
    constructor() {
        this.config = SECURITY_CONFIG;
        this.timeout = this.config.REGEX_TIMEOUT;
        
        // Known dangerous regex patterns
        this.dangerousPatterns = [
            // Exponential backtracking
            /(\w+)*$/,
            /(a+)+$/,
            /(a|a)*$/,
            /(a|ab)*$/,
            
            // Nested quantifiers
            /(\d+)*\d+/,
            /(\w+)+\w+/,
            
            // Overlapping alternations
            /(x+x+)+y/,
            /(.*.*)*$/
        ];
    }

    /**
     * Test regex with VM sandbox and timeout
     * More secure than setTimeout - actually stops execution
     */
    testWithVMSandbox(regex, input, timeoutMs = this.timeout) {
        try {
            // Create isolated context
            const sandbox = {
                regex: regex,
                input: input,
                result: null
            };

            // Create context
            const context = vm.createContext(sandbox);

            // Code to execute
            const code = 'result = regex.test(input);';

            // Run with timeout
            const script = new vm.Script(code);
            script.runInContext(context, {
                timeout: timeoutMs,
                displayErrors: true
            });

            return sandbox.result;
        } catch (error) {
            if (error.code === 'ERR_SCRIPT_EXECUTION_TIMEOUT') {
                throw new ReDoSError(`Regex execution timeout (${timeoutMs}ms): possible ReDoS vulnerability`);
            }
            throw new ReDoSError(`Regex execution failed: ${error.message}`);
        }
    }

    /**
     * Execute regex match with VM sandbox and timeout
     */
    matchWithVMSandbox(regex, input, timeoutMs = this.timeout) {
        try {
            // Create isolated context
            const sandbox = {
                regex: regex,
                input: input,
                result: null
            };

            // Create context
            const context = vm.createContext(sandbox);

            // Code to execute
            const code = 'result = input.match(regex);';

            // Run with timeout
            const script = new vm.Script(code);
            script.runInContext(context, {
                timeout: timeoutMs,
                displayErrors: true
            });

            return sandbox.result;
        } catch (error) {
            if (error.code === 'ERR_SCRIPT_EXECUTION_TIMEOUT') {
                throw new ReDoSError(`Regex execution timeout (${timeoutMs}ms): possible ReDoS vulnerability`);
            }
            throw new ReDoSError(`Regex execution failed: ${error.message}`);
        }
    }

    /**
     * Test regex with timeout (Legacy Promise-based - deprecated)
     * @deprecated Use testWithVMSandbox instead for better security
     */
    testWithTimeout(regex, input, timeoutMs = this.timeout) {
        return new Promise((resolve, reject) => {
            const timeout = setTimeout(() => {
                reject(new ReDoSError(`Regex execution timeout (${timeoutMs}ms): possible ReDoS vulnerability`));
            }, timeoutMs);

            try {
                const result = regex.test(input);
                clearTimeout(timeout);
                resolve(result);
            } catch (error) {
                clearTimeout(timeout);
                reject(error);
            }
        });
    }

    /**
     * Execute regex match with timeout (Legacy Promise-based - deprecated)
     * @deprecated Use matchWithVMSandbox instead for better security
     */
    matchWithTimeout(regex, input, timeoutMs = this.timeout) {
        return new Promise((resolve, reject) => {
            const timeout = setTimeout(() => {
                reject(new ReDoSError(`Regex execution timeout (${timeoutMs}ms): possible ReDoS vulnerability`));
            }, timeoutMs);

            try {
                const result = input.match(regex);
                clearTimeout(timeout);
                resolve(result);
            } catch (error) {
                clearTimeout(timeout);
                reject(error);
            }
        });
    }

    /**
     * Check if regex is potentially dangerous
     */
    isDangerous(regexPattern) {
        const patternStr = regexPattern.toString();

        // Check for nested quantifiers
        if (/\([^)]*[*+]\)[*+]/.test(patternStr)) {
            return {
                dangerous: true,
                reason: 'Nested quantifiers detected',
                pattern: patternStr
            };
        }

        // Check for overlapping alternations with quantifiers
        if (/\([^|]*\|[^)]*\)[*+]/.test(patternStr)) {
            return {
                dangerous: true,
                reason: 'Overlapping alternations with quantifiers',
                pattern: patternStr
            };
        }

        // Check for repeated groups
        if (/\([^)]*[*+][^)]*\)[*+]/.test(patternStr)) {
            return {
                dangerous: true,
                reason: 'Repeated groups detected',
                pattern: patternStr
            };
        }

        // Check for catastrophic backtracking patterns
        if (/\((?:\.\*)+\)[*+]/.test(patternStr)) {
            return {
                dangerous: true,
                reason: 'Catastrophic backtracking pattern',
                pattern: patternStr
            };
        }

        return {
            dangerous: false,
            pattern: patternStr
        };
    }

    /**
     * Analyze regex complexity
     */
    analyzeComplexity(regexPattern) {
        const patternStr = regexPattern.toString();
        
        const metrics = {
            length: patternStr.length,
            quantifiers: (patternStr.match(/[*+?{]/g) || []).length,
            groups: (patternStr.match(/\(/g) || []).length,
            alternations: (patternStr.match(/\|/g) || []).length,
            backtracking: 0,
            complexity: 'LOW'
        };

        // Estimate backtracking potential
        metrics.backtracking = metrics.quantifiers * metrics.groups;

        // Calculate complexity
        if (metrics.backtracking > 20 || metrics.groups > 10) {
            metrics.complexity = 'HIGH';
        } else if (metrics.backtracking > 10 || metrics.groups > 5) {
            metrics.complexity = 'MEDIUM';
        }

        return metrics;
    }

    /**
     * Measure regex execution time
     */
    measureExecutionTime(regex, input) {
        const start = process.hrtime.bigint();
        
        try {
            regex.test(input);
            const end = process.hrtime.bigint();
            const duration = Number(end - start) / 1000000; // Convert to milliseconds
            
            return {
                success: true,
                duration,
                input: input.substring(0, 50) + (input.length > 50 ? '...' : '')
            };
        } catch (error) {
            return {
                success: false,
                error: error.message
            };
        }
    }

    /**
     * Test regex with various inputs
     */
    testRegexSafety(regex) {
        const testInputs = [
            'a'.repeat(10),
            'a'.repeat(50),
            'a'.repeat(100),
            'a'.repeat(500),
            'a'.repeat(1000),
            'x'.repeat(100) + 'y',
            '1'.repeat(100),
            ' '.repeat(100),
            'abc'.repeat(50)
        ];

        const results = [];
        let maxDuration = 0;
        let suspicious = false;

        for (const input of testInputs) {
            const result = this.measureExecutionTime(regex, input);
            results.push(result);

            if (result.success && result.duration > maxDuration) {
                maxDuration = result.duration;
            }

            // If execution time increases exponentially, it's suspicious
            if (result.success && result.duration > 100) {
                suspicious = true;
            }
        }

        return {
            maxDuration,
            suspicious,
            results: results.filter(r => r.success)
        };
    }

    /**
     * Scan code for dangerous regex patterns
     */
    scanCode(content) {
        const findings = [];
        
        // Find regex patterns in code
        const regexPatterns = [
            // JavaScript regex literals
            /\/([^\/\n]+)\/([gimuy]*)/g,
            // new RegExp()
            /new\s+RegExp\s*\(\s*['"]([^'"]+)['"]/g
        ];

        regexPatterns.forEach(pattern => {
            let match;
            while ((match = pattern.exec(content)) !== null) {
                try {
                    const regexStr = match[1];
                    const flags = match[2] || '';
                    const regex = new RegExp(regexStr, flags);

                    const danger = this.isDangerous(regex);
                    const complexity = this.analyzeComplexity(regex);

                    if (danger.dangerous || complexity.complexity === 'HIGH') {
                        findings.push({
                            pattern: regex.toString(),
                            line: content.substring(0, match.index).split('\n').length,
                            dangerous: danger.dangerous,
                            reason: danger.reason,
                            complexity: complexity.complexity,
                            metrics: complexity
                        });
                    }
                } catch (error) {
                    // Invalid regex, skip
                }
            }
        });

        return findings;
    }

    /**
     * Generate ReDoS report
     */
    generateReport(findings) {
        return {
            totalPatterns: findings.length,
            dangerous: findings.filter(f => f.dangerous).length,
            highComplexity: findings.filter(f => f.complexity === 'HIGH').length,
            mediumComplexity: findings.filter(f => f.complexity === 'MEDIUM').length,
            issues: findings.map(f => ({
                pattern: f.pattern,
                line: f.line,
                risk: f.dangerous ? 'HIGH' : f.complexity,
                reason: f.reason || `${f.complexity} complexity regex`
            }))
        };
    }

    /**
     * Safe regex execution wrapper
     * Now uses VM sandbox by default for better security
     */
    safeExec(regex, input, operation = 'test') {
        if (!this.config.ENABLE_REDOS_PROTECTION) {
            // Protection disabled, execute normally
            return operation === 'test' ? regex.test(input) : input.match(regex);
        }

        try {
            // Check if regex is dangerous
            const danger = this.isDangerous(regex);
            if (danger.dangerous) {
                throw new ReDoSError(`Dangerous regex pattern detected: ${danger.reason}`);
            }

            // Execute with VM sandbox (more secure than setTimeout)
            if (operation === 'test') {
                return this.testWithVMSandbox(regex, input);
            } else {
                return this.matchWithVMSandbox(regex, input);
            }
        } catch (error) {
            if (error instanceof ReDoSError) {
                throw error;
            }
            throw new ReDoSError(`Regex execution failed: ${error.message}`);
        }
    }

    /**
     * Safe async regex execution wrapper (for backward compatibility)
     */
    async safeExecAsync(regex, input, operation = 'test') {
        if (!this.config.ENABLE_REDOS_PROTECTION) {
            // Protection disabled, execute normally
            return operation === 'test' ? regex.test(input) : input.match(regex);
        }

        try {
            // Check if regex is dangerous
            const danger = this.isDangerous(regex);
            if (danger.dangerous) {
                throw new ReDoSError(`Dangerous regex pattern detected: ${danger.reason}`);
            }

            // Execute with timeout (Promise-based for async)
            if (operation === 'test') {
                return await this.testWithTimeout(regex, input);
            } else {
                return await this.matchWithTimeout(regex, input);
            }
        } catch (error) {
            if (error instanceof ReDoSError) {
                throw error;
            }
            throw new ReDoSError(`Regex execution failed: ${error.message}`);
        }
    }
}

module.exports = ReDoSProtector;