Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious URI matching template pattern
-
ExploitTrigger catastrophic backtracking in regex engine
-
ImpactConsume CPU resources causing denial of service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Regex complexity limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires Addressable gem versions 2.3.0 through 2.8.x in Ruby applications. Remote unauthenticated attacker can trigger ReDoS by crafting malicious URIs matching URI templates with * (explode) modifier or multiple variables. No victim interaction needed. |
| Impact | The CVSS 3.1 score of 7.5 (High) reflects significant availability impact with favorable attacker conditions: network-accessible attack vector (AV:N), low attack complexity (AC:L), no privileges required (PR:N), and no user interaction needed (UI:N). The vulnerability strictly affects availability (A:H) with no confidentiality or integrity impact, making this a pure denial-of-service issue. Real-world risk is moderate to high for internet-facing Ruby applications that process untrusted URIs through Addressable templates, particularly API endpoints, web proxies, or URL validation services. The attack is easily automatable given the deterministic nature of ReDoS exploitation-attackers need only craft URIs matching vulnerable template patterns to consume CPU resources. However, exploitation requires the application to actively use URI template expansion features with the specific vulnerable patterns (explode modifiers or multi-variable reserved operators), which may limit attack surface in practice. No public exploit identified at time of analysis, and absence of EPSS/KEV data suggests this has not been widely weaponized in the wild, though the technical barrier to exploitation is low. The SSVC framework would likely classify this as Medium priority: exploitation is probable (simple ReDoS), automatable (yes), but technical impact limited to resource consumption rather than compromise. Organizations using affected Addressable versions for URI processing should prioritize patching, especially for public-facing services. |
| Exploit ScenarioDerived | An attacker identifies a public API endpoint that uses Addressable for URI template matching, such as a REST API implementing RFC 6570 templated routes like /api/{+path*}/resource. The attacker crafts a malicious URI with a deeply nested structure designed to trigger catastrophic backtracking, such as /api/ followed by hundreds of characters matching the vulnerable pattern (e.g., repeating sequences exploiting the nested quantifiers in explode modifier patterns). Submitting this URI causes the application's regex engine to enter exponential-time backtracking, consuming CPU resources for seconds or minutes per request. By sending concurrent requests with such payloads, the attacker exhausts available CPU on application servers, rendering the service unresponsive to legitimate users. No public exploit identified at time of analysis, but the attack technique is well-documented in ReDoS literature and requires only HTTP client access. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Apr 07, 2026
Regular expression denial of service (ReDoS) in the Addressable Ruby library versions 2.3.0 through 2.8.x allows unauthenticated remote attackers to cause application-level denial of service through maliciously crafted URIs that trigger catastrophic backtracking in URI template expansion. The vulnerability affects URI templates using explode modifiers (e.g., {foo*}, {+var*}) and multi-variable templates with + or
operators (e.g., {+v1,v2,v3}), generating O(2^n) and O(n^k) complexity regex patterns respectively. EPSS exploitation probability and KEV status data not available; no public exploit identified at time of analysis. Vendor-released patch: version 2.9.0.
RemediationAI
Upgrade Addressable to version 2.9.0 or later, which contains the vendor-released patch addressing both catastrophic backtracking vulnerabilities in URI template regular expression generation. For Ruby applications using Bundler, update the Gemfile to specify addressable version constraint ~> 2.9.0 or >= 2.9.0, then run bundle update addressable to apply the fix. If immediate upgrade is not feasible, implement workarounds including input validation to reject URIs exceeding reasonable length thresholds (e.g., 2048 characters), applying timeout constraints to URI template expansion operations, or avoiding use of URI templates with explode modifiers and multi-variable reserved operators on untrusted input. Review application code to identify URI template usage patterns, particularly in API routing, URL generation, or proxy functionality. Consult the GitHub Security Advisory at https://github.com/sporkmonger/addressable/security/advisories/GHSA-h27x-rffw-24p4 for detailed technical context and vendor recommendations. Test thoroughly after upgrade to ensure compatibility with application-specific URI handling logic.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in rubygems
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Addressable is a widely-used Ruby gem providing URI handling capabilities as an alternative to Ruby's standard library URI implementation. The vulnerability resides in the URI template expansion mechanism (RFC 6570), specifically in how the library generates regular expressions for template matching. Two distinct flaws exist: first, templates using the explode modifier (*) with any expansion operator create regex patterns with nested unbounded quantifiers, resulting in exponential time complexity O(2^n) during backtracking. Second, templates with multiple variables using reserved character operators (+ or #) generate patterns where the comma separator falls within the matched character class, creating ambiguous backtracking states across k variables with O(n^k) complexity. This is classified as CWE-1333 (Inefficient Regular Expression Complexity), a common ReDoS vulnerability class where algorithmic complexity in regex engines can be weaponized. The affected CPE (cpe:2.3:a:sporkmonger:addressable) encompasses all versions from 2.3.0 to pre-2.9.0, impacting any Ruby application using Addressable for URI template processing, particularly web frameworks, API clients, and URL routing systems.
Know when Addressable gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Addressable is an alternative implementation to the URI implementation that is part of Ruby's standard library. From 2.3.0 to before 2.9.0, within the URI template implementation in Addressable, two classes of URI template generate regular expressions vulnerable to catastrophic backtracking. Templates using the * (explode) modifier with any expansion operator (e.g., {foo*}, {+var*}, {#var*}, {/var*}, {.var*}, {;var*}, {?var*}, {&var*}) generate patterns with nested unbounded quantifiers that are O(2^n) when matched against a maliciously crafted URI. Templates using multiple variables with the + or
operators (e.g., {+v1,v2,v3}) generate patterns with O(n^k) complexity due to the comma separator being within the matched character class, causing ambiguous backtracking across k variables. When matched against a maliciously crafted URI, this can result in catastrophic backtracking and uncontrolled resource consumption, leading to denial of service. This vulnerability is fixed in 2.9.0.
Executive ViewAI
CVE-2026-35611 is a regular expression denial of service vulnerability in the Addressable Ruby library (versions 2.3.0-2.8.x) that allows unauthenticated attackers to crash applications through maliciously crafted URIs, potentially disrupting service availability for any organization using affected versions in production environments.
Pending vendor patch availability confirmation: implement input validation to reject URIs exceeding reasonable length thresholds (e.g., >2,048 characters), restrict URI template expansion operations to trusted/internal data sources only, deploy rate-limiting on URI processing endpoints to mitigate repeated exploitation attempts, and consider WAF rules to filter malformed URI patterns; however, these measures do not fully eliminate the ReDoS risk and patch application is required.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
More in Addressable
View allSame technique Denial Of Service
View allVendor StatusVendor
SUSE
Severity: High| Product | Status |
|---|---|
| SUSE Linux Enterprise Module for Package Hub 15 SP7 | Fixed |
| openSUSE Leap 15.6 | Fixed |
| SUSE Linux Enterprise Module for Package Hub 15 SP5 | Fixed |
| SUSE Linux Enterprise Module for Package Hub 15 SP6 | Fixed |
| openSUSE Leap 15.3 | Fixed |
| openSUSE Leap 15.4 | Fixed |
| openSUSE Leap 15.5 | Fixed |
EUVD-2026-19788
GHSA-h27x-rffw-24p4
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB