Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify internet-facing dd-trace-rb service
-
DeliveryCraft baggage header with massive key-value count
-
ExploitSend unauthenticated HTTP requests
-
ExecutionTracer allocates hash-map entry per pair
-
PersistRepeat to exhaust CPU and memory
-
ImpactDenial of Service / crash
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 Ruby service be instrumented with dd-trace-rb ( |
| Impact | The CVSS 3.1 score of 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) accurately captures a network-reachable, low-complexity, unauthenticated availability-only impact with no confidentiality or integrity loss. No EPSS score, KEV listing, SSVC decision, or POC was provided in the input, so exploitation likelihood must be inferred from the mechanics rather than measured signals. The attack is trivially automatable and requires no special conditions beyond the default-enabled baggage propagation style, which raises real-world concern; however, the impact ceiling is service disruption only, not compromise. This is a legitimate availability priority for internet-facing Ruby services but is not a data-breach-class emergency - absent KEV or EPSS data, treat exploitation as plausible-but-unconfirmed rather than known-active. |
| Exploit ScenarioDerived | An attacker identifies an internet-facing Ruby web service instrumented with a vulnerable dd-trace-rb version and sends HTTP requests carrying a |
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 Datadog's dd-trace-rb Ruby tracing library (versions before 2.32.0) allows attackers to exhaust CPU and memory by sending HTTP requests with oversized or high-cardinality W3C baggage headers. Because the DD_TRACE_BAGGAGE_MAX_ITEMS (64) and DD_TRACE_BAGGAGE_MAX_BYTES (8192) limits were enforced only on injection and not extraction, the tracer allocates a hash-map entry per comma-separated pair on every request. Baggage propagation is enabled by default, so any internet-facing instrumented Ruby service is exposed; no public exploit was identified at time of analysis, and this CVE is not listed in CISA KEV.
RemediationAI
Vendor-released patch: upgrade the datadog RubyGem to version 2.32.0 or later, which enforces the item-count and byte-size limits on the extract path, per GHSA-p5f6-rccc-jv98 (https://github.com/DataDog/dd-trace-rb/security/advisories/GHSA-p5f6-rccc-jv98). If immediate upgrade is not possible, disable baggage extraction by removing baggage from DD_TRACE_PROPAGATION_STYLE (or DD_TRACE_PROPAGATION_STYLE_EXTRACT if set independently), with the trade-off that inbound baggage context will no longer be propagated into traces. As an additional layer, cap 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 overly aggressive limits may reject legitimate large-header requests and must be tuned to your application.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in rubygems, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The vulnerability lives in the W3C Trace Context / OpenTelemetry baggage propagation mechanism, a standard for carrying arbitrary key-value pairs across distributed-tracing hops via the baggage HTTP header. dd-trace-rb (the datadog RubyGem, CPE pkg:rubygems/datadog) parses this header on the extract path by splitting on commas and allocating a hash-map entry for each pair, but omitted the count and byte-size caps that already guarded the inject path. This is a classic CWE-400 Uncontrolled Resource Consumption: attacker-controlled input directly drives unbounded allocation and CPU work. The same defect class was addressed in sibling libraries opentelemetry-go (GHSA-mh2q-q3fh-2475) and opentelemetry-dotnet (GHSA-g94r-2vxg-569j), indicating a cross-ecosystem baggage-parsing pattern.
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 attacker sends a crafted header with no user interaction (AV:N/AC:L/PR:N/UI:N); impact is availability-only resource exhaustion, so C:N/I:N/A:H, scope unchanged.
Primary rating from Vendor (https://github.com/DataDog/dd-trace-rb).
CVSS VectorVendor: https://github.com/DataDog/dd-trace-rb
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 2.32.0 and later of the dd-trace-rb 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-rb Ruby tracing library (versions prior to 2.32.0) contains an unauthenticated remote denial-of-service vulnerability allowing attackers to exhaust CPU and memory on internet-facing instrumented Ruby services. Since baggage propagation is enabled by default and no vendor patch is currently available, all affected applications face potential service disruption risk. Organizations must implement interim protections immediately to prevent attackers from taking critical services offline.
Implement WAF rules to reject HTTP requests with oversized or high-cardinality W3C baggage headers; disable trace baggage propagation in non-production environments; enable request rate limiting and connection throttling on affected services; deploy monitoring and alerting for abnormal CPU and memory usage patterns; network-segment internet-facing services from critical internal infrastructure. These interim controls reduce denial-of-service risk until a vendor patch becomes available from Datadog.
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
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
The STARTTLS implementation in mail/ngx_mail_smtp_handler.c in the SMTP proxy in nginx 1.5.x and 1.6.x before 1.6.1 and
EUVD-2026-77671
GHSA-p5f6-rccc-jv98
NVD
CVE.org
EPSS
Exploit-DB