Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify route using slug() matcher
-
DeliverySend request with 50k-char slug ending in '_'
-
ExploitTrigger quadratic regex backtracking
-
ExecutionPin CPU and block event loop
-
ImpactWorker stops serving requests/health checks
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption 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 | Exploitable only when the application explicitly applies router.matchers.slug() to an attacker-controlled route parameter - this is the precise prerequisite feature, not a default for every AdonisJS app. Where that matcher is used, no authentication or user interaction is required (PR:N/UI:N) and the attack reaches the vulnerable regex before any route/group middleware runs, so authentication and rate-limiting middleware on the route do NOT prevent it. The practical limiting factors are therefore: (1) the app must use the slug matcher on an externally reachable route, and (2) impact is availability-only (event-loop stall / worker DoS) with no data exposure; versions 8.2.2 and 9.1.1 remove the backtracking regex. |
| Impact | This is a genuine availability risk for the specific population of applications that use it, but not a universal emergency. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) and the description agree cleanly: a single unauthenticated network request carrying a crafted slug triggers quadratic regex backtracking (ReDoS, CWE-400) that stalls the Node.js single-threaded event loop, blocking the worker from serving any other request or health check. The 8.7 score is driven entirely by VA:H (availability); there is no confidentiality or integrity impact (VC:N/VI:N), so this is a pure DoS. A notable amplifier, stated explicitly in the description and traceable to AdonisJS routing internals, is that route matching runs BEFORE route/group middleware, so authentication and rate-limiting middleware do NOT shield the vulnerable matcher - the usual mitigating controls are bypassed. The key qualifier that lowers real-world priority is that the flaw only manifests when an application actually applies router.matchers.slug() to an attacker-controlled route parameter; applications that do not use this matcher are unaffected. No EPSS score and no CISA KEV entry were provided, and there is no evidence of active exploitation - exploitation status is therefore: no confirmed active exploitation. A reproducing regression test shipping in the fix commit demonstrates the backtracking with a 50,000-character malicious slug, so a working reproduction is publicly available. Net: a legitimately high-severity DoS for affected deployments, worth prompt patching, but its blast radius is gated by whether the slug matcher is in use rather than being a blanket remote-DoS against all AdonisJS apps. |
| Exploit ScenarioDerived | An unauthenticated attacker identifies a route whose parameter is validated with router.matchers.slug() and sends a request containing a very long slug (e.g. tens of thousands of characters) ending in a character the final assertion rejects, such as an underscore. The regex enters quadratic backtracking, pinning a CPU core and freezing the Node.js event loop so the worker can no longer serve legitimate traffic or respond to health checks. A publicly reproducing test case (50,000 'a' characters followed by '_') exists in the fix commit, making the condition trivial to reproduce. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 15, 2026
Denial of service in AdonisJS HTTP Server (adonisjs/http-server) lets unauthenticated remote attackers stall the Node.js event loop: versions prior to 8.2.2 and 9.1.1 contain a catastrophic-backtracking regular expression in router.matchers.slug(), and a long slug ending in a character rejected by the final assertion triggers quadratic CPU consumption. Because the matcher runs during route matching and before route and group middleware, authentication or rate-limiting middleware attached to the affected route does not prevent the request from blocking the worker and starving unrelated requests and health checks. Impact is availability-only with no data exposure, the CVSS 4.0 base score is 8.7 (assessed CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), no public exploit identified at time of analysis, and exploitation requires the application to explicitly apply the slug matcher to an externally reachable, attacker-controlled route parameter rather than affecting every AdonisJS deployment.
RemediationAI
Vendor-released patch: 8.2.2 and 9.1.1 - upgrade AdonisJS HTTP Server to 8.2.2 (8.x line) or 9.1.1 (9.x line) as documented in GitHub advisory GHSA-524c-h47v-m3h8 and the release tags v8.2.2 and v9.1.1; the fix commits 86af38ca861528f673dcac6a4806197de038d1f7 and d8c749aa9f66d5d214bad1cad727264aef4be727 replace the backtracking regex with a linear-time equivalent. Where upgrading is not immediately possible, stop applying router.matchers.slug() to attacker-controlled route parameters - either substitute a custom non-backtracking matcher or validate and length-limit the parameter before matching - accepting that this requires code changes and may alter accepted slug formats. Route- and group-level middleware (including authentication and rate limiting) is not a reliable mitigation because matching occurs before middleware executes; instead, enforce request-line or path-length limits at the reverse proxy or load balancer in front of the Node.js process (for example, capping URI length in nginx or the ingress controller) so oversized slugs are rejected before reaching the worker, with the trade-off that legitimate long URLs may also be blocked. Also consider running multiple workers or clustering to reduce the blast radius of a single stalled event loop, though this only limits rather than prevents the availability impact. No vendor-released patch other than the two fixed versions above is identified.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in npm, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The vulnerability is CWE-400 uncontrolled resource consumption expressed as regular-expression denial of service. The pre-fix matcher in src/router/matchers.ts returned the pattern /^[^\s-_](?!.*?[-_]{2,})([a-z0-9-\\]{1,})[^\s]*[^-_\s]$/, in which adjacent greedy repetitions with overlapping character classes and nested alternation create exponentially many ways to partition the input before the final assertion fails, producing quadratic backtracking on inputs such as a long run of characters followed by an invalid trailing character. AdonisJS HTTP Server is the request-routing package of the AdonisJS framework, and RouteMatchers.slug() is a helper intended to validate slug-style route parameters; when developers attach it to a route parameter, the regex is evaluated during route matching, which occurs before route-level and group-level middleware in the request lifecycle. Since Node.js executes JavaScript on a single thread, the CPU-bound backtracking blocks the event loop and stops the worker from processing any other request, including health checks, until matching completes. The upstream fix replaces the pattern with /^[^\s_-](?=[a-z0-9\\-])(?=.{2})(?:[^\s_-]|[-_][^\s_-])+$/, which removes the ambiguous nested repetition, and the accompanying test asserts that a 50,000-character malicious slug is rejected in under 250 ms. CPE data identifies the affected package stream as cpe:2.3:a:adonisjs:http-server:*:*:*:*:*:*:*:* across the affected version ranges.
Know when Http Server 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
A single crafted unauthenticated HTTP request triggers the ReDoS (AV:N/AC:L/PR:N/UI:N) causing worker DoS, so A:H with C:N/I:N and no scope change.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
AdonisJS HTTP Server is a package for handling HTTP requests in the AdonisJS framework. Prior to 8.2.2 and 9.1.1, the regular expression returned by router.matchers.slug() contains adjacent greedy repetitions with overlapping character classes. When an application applies this matcher to an attacker-controlled route parameter, a long slug ending in a character rejected by the final assertion causes quadratic backtracking and excessive CPU use. Route matching occurs before route and group middleware, so authentication or rate-limiting middleware attached to the route may not prevent an unauthenticated request from blocking the Node.js event loop and stopping the worker from serving unrelated requests or health checks. This issue is fixed in versions 8.2.2 and 9.1.1.
Technical POC Analysis
Bug class: inefficient regular expression complexity leading to uncontrolled resource consumption - the advisory carries both CWE-1333 (Inefficient Regular Expression Complexity) and CWE-400 (Uncontr…
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
AdonisJS HTTP Server versions prior to 8.2.2 and 9.1.1 contain a denial-of-service vulnerability in the slug matcher that allows unauthenticated remote attackers to stall the Node.js event loop via a long slug parameter, causing service unavailability; no public exploit identified at time of analysis. Organizations using these versions and explicitly applying the slug matcher to externally reachable, attacker-controlled route parameters are at risk because the matcher runs before middleware, so authentication and rate-limiting on the route do not prevent exploitation. Leadership should prioritize mitigation as no vendor-released patch identified at time of analysis and a successful attack can disrupt critical services and health checks.
Implement rate limiting at the reverse proxy or load balancer level, enforce URL length restrictions, deploy WAF rules to block malicious slug patterns, and avoid using the slug matcher on externally reachable routes until a patch is available.
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 Http Server
View allA crafted request uri-path can cause mod_proxy to forward the request to an origin server choosen by the remote user.4.4
Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour
Apache httpd allows remote attackers to read secret data from process memory if the Limit directive can be set in a user
The RC4 algorithm, as used in the TLS protocol and SSL protocol, has many single-byte biases, which makes it easier for
Race condition in the mod_status module in the Apache HTTP Server before 2.4.10 allows remote attackers to cause a denia
The mod_http2 module in the Apache HTTP Server 2.4.17 through 2.4.23, when the Protocols configuration includes h2 or h2
Oracle HTTP Server and WebLogic Server Proxy Plug-in have a CVSS 10.0 access control vulnerability allowing unauthentica
Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due
The mod_headers module in the Apache HTTP Server 2.2.22 allows remote attackers to bypass "RequestHeader unset" directiv
mod_session_dbd.c in the mod_session_dbd module in the Apache HTTP Server before 2.4.5 proceeds with save operations for
The Apache HTTP Server through 2.4.23 follows RFC 3875 section 4.1.18 and therefore does not protect applications from t
The HTTP strict parsing changes added in Apache httpd 2.2.32 and 2.4.24 introduced a bug in token list parsing, which al
EUVD-2026-102320
GHSA-524c-h47v-m3h8
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB