# Regex ReDoS Vulnerability Detector MCP for AI Agents AI Agent Connect > Regex ReDoS Vulnerability Detector finds catastrophic backtracking and high-risk patterns in your regular expressions. It identifies nested quantifiers and overlapping alternations that cause event loop freezing in Node.js environments, helping you secure your regex patterns before they hit production. ## Overview - **Category:** security - **Price:** Free - **Endpoint:** https://edge.vinkius.com/vk_preview_5XGokJ2Yzbf2uKL66VEDmLZLI4OWE943MqhKy7mw/ai-agent-connect - **Tags:** redos, security, regex, vulnerability, backtracking, nodejs ## Description You're writing code, testing a new pattern, and everything seems fine until a specific input causes your entire Node.js process to hang. That's the classic ReDoS attack. This MCP lets your AI client scan regular expressions for the structural flaws that trigger catastrophic backtracking. Instead of manually parsing complex patterns, you can just hand them over to your agent to check for nested quantifiers or overlapping branches. It doesn't just point out the problem; it gives you a clear path to fix it so your application stays responsive under load. Since this is part of the Vinkius catalog, you can connect it once and use it across all your favorite coding environments like Cursor or VS Code. You get precise identification of vulnerable substrings and actual strategies to refactor them safely. ## Tools ### generate_remediation_report Creates a detailed guide on how to fix identified vulnerabilities. It gives you actionable steps to rewrite your patterns safely. ### evaluate_security_posture Measures the overall risk level of specific regex features. Use this to understand if an alternation or quantifier is dangerous. ### detect_structural_features Scans a pattern for high-risk structural elements like nested quantifiers. It finds the exact substrings that cause backtracking. ## Prompt Examples **Prompt:** ``` Is this regex pattern safe for production: `(a+)+$`? ``` **Response:** ``` No, it's not safe. The pattern contains a nested quantifier which is a major ReDoS risk. This will cause catastrophic backtracking when processing certain inputs. ``` **Prompt:** ``` Check the security of these features: ['overlapping_alternation']. ``` **Response:** ``` The presence of overlapping alternation increases your risk level. While not an immediate crash, it can lead to significant performance degradation under load. ``` **Prompt:** ``` How should I fix this vulnerable regex? ``` **Response:** ``` You should refactor the pattern to avoid redundant checks. Instead of using overlapping branches, try to make each part of the alternation mutually exclusive. ``` ## Capabilities ### Identify backtracking risks Finds patterns that trigger catastrophic engine behavior. ### Assess regex risk levels Determines how dangerous specific features are to your runtime. ### Generate fix instructions Provides clear steps to rewrite vulnerable patterns. ### Scan for structural flaws Looks for nested quantifiers and overlapping alternations. ## Use Cases ### Auditing user input validation A developer is worried a new email regex might be vulnerable. They ask their agent to check it, and the MCP identifies a nested quantifier risk. ### Securing API routing rules An engineer needs to ensure complex path matching doesn't cause latency. The agent scans the patterns and flags overlapping alternations. ### Refactoring legacy regex code You find an old, complex pattern in a Node.js service. Your agent uses remediation reports to suggest a safer version. ## Benefits - Prevent service outages by catching nested quantifiers before they reach production. - Reduce manual auditing time using structural scanning to find vulnerabilities instantly. - Get clear instructions for fixes via detailed remediation reports. - Identify high-risk alternations to prevent performance degradation. - Protect Node.js event loops from freezing during heavy traffic. ## How It Works The bottom line is you stop deploying patterns that can crash your server. 1. Provide the regex pattern you want to check to your agent. 2. The MCP analyzes the pattern's structure for known ReDoS triggers. 3. Your agent returns a breakdown of risks and suggested fixes. ## Frequently Asked Questions **How can I prevent ReDoS with Regex ReDoS Vulnerability Detector?** Use the MCP to scan your patterns for nested quantifiers and overlapping structures before you commit them to your codebase. **Can this tool find vulnerabilities in my Node.js app?** Yes, it specifically looks for patterns that cause event loop freezing in Node.js environments like V8. **Does Regex ReDoS Vulnerability Detector work with any regex engine?** It is optimized for engines like V8, but the structural analysis of quantifiers and alternations applies to most modern regex implementations. **What does a remediation report look like?** You'll get a clear breakdown of the vulnerable parts of your pattern along with specific instructions on how to rewrite them safely. **How do I know if my regex is high risk?** The tool analyzes the structure for features like nested quantifiers and flags them as high-risk hazards immediately. **How does the tool identify a vulnerability without executing the regex?** The `detect_structural_features` tool uses deterministic meta-parsing to inspect the string structure. It identifies hazardous constructs like nested quantifiers (e.g., `(a+)+`) by analyzing the arrangement of characters and symbols without actually attempting a match against a subject string, thus avoiding any risk of triggering the vulnerability itself. **What information is provided in the remediation report?** The `generate_remediation_report` tool provides a list of `vulnerableSubstrings` within your pattern and a `recommendationString`. This includes specific instructions on how to refactor the pattern, such as using non-capturing groups or atomic grouping, to eliminate backtracking risks. **Can I use this to evaluate the risk score of a pattern?** Yes, by using `evaluate_security_posture`, you can pass identified features to receive an `isSafe` boolean and a numerical `riskScore`. This score is calculated based on the frequency and severity of detected structural hazards like overlapping alternations.