Skip to main content

Addressable EUVDEUVD-2026-19788

| CVE-2026-35611 HIGH
Inefficient Regular Expression Complexity (ReDoS) (CWE-1333)
2026-04-07 GitHub_M GHSA-h27x-rffw-24p4
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Craft malicious URI matching template pattern
  2. Exploit
    Trigger catastrophic backtracking in regex engine
  3. Impact
    Consume 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.0% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

addressable 2.3.0, < 2.9.0

Affected Packages

rubygems addressable fix: 2.9.0

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

Vendor (GitHub_M) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
SUSE HIGH
Red Hat 6.5 MEDIUM

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

2
Patch released
Apr 08, 2026 - 02:30 nvd
Patch available
CVE Published
Apr 07, 2026 - 16:38 nvd
HIGH 7.5

DescriptionCVE.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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.0%
Top 88% exploitable
Threat Intel
1
1 source
Data Quality
8 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor GitHub VulDB

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.0%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

Vendor 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

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy