Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify internet-facing service using dd-trace
-
DeliveryCraft HTTP request with massive baggage header
-
ExploitTracer parses pairs without limits
-
ExecutionUnbounded hash-map allocation per request
-
PersistFlood requests to exhaust CPU/memory
-
ImpactService denial of service
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 | Exploitation requires that the target HTTP service is instrumented with a vulnerable dd-trace-js version (< 5.100.0) and has the 'baggage' propagation style enabled on the extract path - which is the default in most affected tracers, so no non-default tuning is needed unless an operator has explicitly narrowed DD_TRACE_PROPAGATION_STYLE / DD_TRACE_PROPAGATION_STYLE_EXTRACT to exclude baggage. The service must also be reachable by the attacker over HTTP. No authentication, credentials, or user interaction are required (PR:N/UI:N). The main limiting factors are: the tracer must actually process the inbound baggage header (baggage not removed from the extract propagation styles), and an upstream proxy/web server enforcing a small max-header-size will blunt or block the oversized header before it reaches the tracer. |
| Impact | The signals are internally consistent and point to a genuine, easily reachable availability risk. The CVSS vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H describes network reach, low complexity, no privileges and no user interaction, with impact isolated to availability (C:N/I:N) - accurate for a DoS. The key amplifier beyond raw CVSS is deployment posture: baggage propagation is enabled by default, so exploitation needs no special target configuration, only that an affected tracer version instruments an internet-facing HTTP service. Tempering factors: this is availability-only (no data disclosure or code execution), and the impact is a resource-exhaustion DoS rather than compromise, so it is a priority for exposed high-availability services but not a confidentiality/integrity emergency. No EPSS score was provided in the input, so exploitation-probability cannot be quantified; it is not in CISA KEV and no POC is referenced, so there is currently no evidence of active exploitation despite the low attack complexity. |
| Exploit ScenarioDerived | An attacker identifies an internet-facing Node.js service instrumented with a vulnerable dd-trace version and sends a single crafted HTTP request whose 'baggage' header contains hundreds of thousands of comma-separated key=value pairs (or one enormous value). The tracer parses and allocates a hash-map entry for every pair on each request, spiking CPU and memory; repeating the request rapidly drives the service to exhaustion and unavailability. Exploitation needs no authentication or user interaction (AV:N/AC:L/PR:N/UI:N), though no public POC is referenced at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 15, 2026
Remote unauthenticated Denial of Service in the Datadog dd-trace-js Node.js tracing library (versions < 5.100.0) allows attackers to exhaust CPU and memory by sending an HTTP request with an oversized W3C 'baggage' header. Because the DD_TRACE_BAGGAGE_MAX_ITEMS (64) and DD_TRACE_BAGGAGE_MAX_BYTES (8192) caps were enforced only on injection and not on the extraction path, the tracer allocates a hash-map entry per comma-separated pair on every request. With baggage propagation enabled by default, any internet-facing instrumented service is exposed. CVSS 3.1 base score is 7.5 (A:H); there is no public exploit identified at time of analysis and it is not listed in CISA KEV.
RemediationAI
Vendor-released patch: upgrade dd-trace to 5.100.0 or later, which enforces the item-count and byte-size caps on the extraction path per GHSA-wxqq-gcq8-c443. If immediate upgrade is not possible, disable baggage extraction by removing 'baggage' from DD_TRACE_PROPAGATION_STYLE (or from DD_TRACE_PROPAGATION_STYLE_EXTRACT if configured independently); the trade-off is loss of baggage-based context propagation in distributed traces while other propagation styles continue to function. As a defense-in-depth control, cap the maximum HTTP request header size at an upstream proxy or web server - for example Apache LimitRequestFieldSize, Nginx large_client_header_buffers, or Envoy max_request_headers_kb - noting that an overly aggressive limit can reject legitimate large-header requests, so tune it above normal traffic. Consult the advisory at https://github.com/DataDog/dd-trace-js/security/advisories/GHSA-wxqq-gcq8-c443 for details.
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 flaw sits in dd-trace-js's implementation of W3C Trace Context 'baggage' propagation, a standard mechanism for carrying user-defined key-value context across distributed services via the 'baggage' HTTP header (comma-separated key=value pairs). On the extract/parse path the library iterates the incoming header and allocates a hash-map entry for each pair without bounding the number of items or total byte size, so attacker-controlled input directly drives unbounded allocation and parsing work. This is a classic CWE-400 (Uncontrolled Resource Consumption) issue: the same DD_TRACE_BAGGAGE_MAX_ITEMS and DD_TRACE_BAGGAGE_MAX_BYTES limits that protect the inject path were never wired into extraction. The affected package is the npm distribution pkg:npm/dd-trace. The advisory notes the same design defect affected sibling OpenTelemetry tracers (opentelemetry-go GHSA-mh2q-q3fh-2475, opentelemetry-dotnet GHSA-g94r-2vxg-569j), indicating a cross-ecosystem parsing pattern rather than a single-library mistake.
Know when Nginx 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
Remote, unauthenticated, low-complexity header parsing against default-enabled baggage yields PR:N/AC:L/AV:N; impact is availability-only resource exhaustion, so C:N/I:N/A:H.
Primary rating from Vendor (https://github.com/DataDog/dd-trace-js).
CVSS VectorVendor: https://github.com/DataDog/dd-trace-js
DescriptionCVE.org
Impact
Datadog tracing libraries that implement W3C baggage propagation parse incoming baggage HTTP headers without enforcing item-count or byte-size limits on the extract path. The DD_TRACE_BAGGAGE_MAX_ITEMS (default 64) and DD_TRACE_BAGGAGE_MAX_BYTES (default 8192) limits were applied only to baggage injection, not extraction. A remote, unauthenticated attacker can send a request whose baggage header contains an arbitrarily large number of comma-separated key-value pairs (or a single very large value). The tracer allocates a hash-map entry for each pair on every request, causing unbounded CPU and memory consumption and enabling a remote Denial of Service against any HTTP service that has the baggage propagation style enabled. The baggage propagation style is enabled by default in most affected tracers, so any internet-facing service that has been instrumented with an affected tracer version is exposed unless the propagation style has been explicitly narrowed.
Patches
This is resolved in version 5.100.0 and later of the dd-trace-js library.
Workarounds
If users cannot upgrade immediately:
- Disable
baggageextraction by removingbaggagefromDD_TRACE_PROPAGATION_STYLE(orDD_TRACE_PROPAGATION_STYLE_EXTRACTif set independently). - Cap the maximum HTTP request header size at an upstream proxy or web server (for example, Apache
LimitRequestFieldSize, Nginxlarge_client_header_buffers, Envoymax_request_headers_kb).
Resources
Related upstream advisories: opentelemetry-go GHSA-mh2q-q3fh-2475 opentelemetry-dotnet GHSA-g94r-2vxg-569j
Articles & Coverage 2
Executive ViewAI
The Datadog dd-trace-js Node.js tracing library in versions before 5.100.0 contains a remote denial-of-service vulnerability that allows attackers to exhaust CPU and memory on internet-facing instrumented services through oversized tracing headers. Organizations face immediate availability risk across any application using this library in production without compensating controls.
No vendor-released patch identified at time of analysis. Interim mitigation: Web Application Firewall rules to enforce maximum baggage header size (8,192 bytes), rate limiting per source IP at reverse proxy level (recommend 10-20 req/sec), optionally disable W3C baggage propagation if operationally feasible, and establish monitoring alerts for abnormal memory consumption or CPU utilization correlated with dd-trace-js baggage processing.
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.
Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour
The ngx_http_parse_chunked function in http/ngx_http_parse.c in nginx 1.3.9 through 1.4.0 allows remote attackers to cau
A critical vulnerability in Kubernetes ingress-nginx controller allows unauthenticated attackers with pod network access
nginx 0.8.41 through 1.4.3 and 1.5.x before 1.5.7 allows remote attackers to bypass intended restrictions via an unescap
An issue was discovered on GL.iNet devices before version 4.5.0. Rated critical severity (CVSS 9.8), this vulnerability
Nginx versions since 0.5.6 up to and including 1.13.2 are vulnerable to integer overflow vulnerability in nginx range fi
The resolver in nginx before 1.8.1 and 1.9.x before 1.9.10 allows remote attackers to cause a denial of service (invalid
Kubernetes ingress-nginx contains a configuration injection vulnerability via the mirror-target and mirror-host Ingress
Nginx UI is a web user interface for the Nginx web server. Rated high severity (CVSS 8.9), this vulnerability is remotel
A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-url` Ingres
A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-tls-match-c
Roxy-WI is a web interface for managing Haproxy, Nginx, Apache and Keepalived servers. Rated critical severity (CVSS 9.8
EUVD-2026-45323
GHSA-wxqq-gcq8-c443
NVD
CVE.org
EPSS
Exploit-DB