Skip to main content

dd-trace-js EUVDEUVD-2026-45323

| CVE-2026-50272 HIGH
Uncontrolled Resource Consumption (CWE-400)
2026-07-15 https://github.com/DataDog/dd-trace-js GHSA-wxqq-gcq8-c443
7.5
CVSS 3.1 · Vendor: https://github.com/DataDog/dd-trace-js
View

Attack ChainAIDerived

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

  1. Access
    Identify internet-facing service using dd-trace
  2. Delivery
    Craft HTTP request with massive baggage header
  3. Exploit
    Tracer parses pairs without limits
  4. Execution
    Unbounded hash-map allocation per request
  5. Persist
    Flood requests to exhaust CPU/memory
  6. Impact
    Service 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.

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

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

Alert me

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

dd-trace-js < 5.100.0

Affected Packages

npm dd-trace fix: 5.100.0
euvd dd_trace_js fix: 5.100.0

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

Vendor (https://github.com/DataDog/dd-trace-js) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (https://github.com/DataDog/dd-trace-js).

CVSS VectorVendor: https://github.com/DataDog/dd-trace-js

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

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:

  1. Disable baggage extraction by removing baggage from DD_TRACE_PROPAGATION_STYLE (or DD_TRACE_PROPAGATION_STYLE_EXTRACT if set independently).
  2. Cap the maximum HTTP request header size at an upstream proxy or web server (for example, Apache LimitRequestFieldSize, Nginx large_client_header_buffers, Envoy max_request_headers_kb).

Resources

Related upstream advisories: opentelemetry-go GHSA-mh2q-q3fh-2475 opentelemetry-dotnet GHSA-g94r-2vxg-569j

Executive ViewAI

Why It Matters

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.

Business Impact: High
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

EPSS Score
0.8%
Top 48% exploitable
Prevalence
High
widely deployed Node.js APM tracing library in enterprise environments
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium

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.8%
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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

39
Low Medium High Critical
KEV: 0
EPSS: +1
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.

More in Nginx

View all
CVE-2023-44487 HIGH POC
7.5 Oct 10

Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour

CVE-2013-2028 HIGH POC
7.5 Jul 20

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

CVE-2025-1974 CRITICAL POC
9.8 Mar 25

A critical vulnerability in Kubernetes ingress-nginx controller allows unauthenticated attackers with pod network access

CVE-2013-4547 HIGH POC
7.5 Nov 23

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

CVE-2023-50919 CRITICAL POC
9.8 Jan 12

An issue was discovered on GL.iNet devices before version 4.5.0. Rated critical severity (CVSS 9.8), this vulnerability

CVE-2017-7529 HIGH
7.5 Jul 13

Nginx versions since 0.5.6 up to and including 1.13.2 are vulnerable to integer overflow vulnerability in nginx range fi

CVE-2016-0742 HIGH
7.5 Feb 15

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

CVE-2025-1098 HIGH POC
8.8 Mar 25

Kubernetes ingress-nginx contains a configuration injection vulnerability via the mirror-target and mirror-host Ingress

CVE-2024-49368 HIGH POC
8.9 Oct 21

Nginx UI is a web user interface for the Nginx web server. Rated high severity (CVSS 8.9), this vulnerability is remotel

CVE-2025-24514 HIGH POC
8.8 Mar 25

A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-url` Ingres

CVE-2025-1097 HIGH POC
8.8 Mar 25

A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-tls-match-c

CVE-2022-31137 CRITICAL POC
9.8 Jul 08

Roxy-WI is a web interface for managing Haproxy, Nginx, Apache and Keepalived servers. Rated critical severity (CVSS 9.8

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