Datadog - CraftedSignal Threat Feed

Datadog dd-trace-go Library Vulnerability May Lead to Denial of Service

hello@craftedsignal.io — Wed, 15 Jul 2026 23:06:22 +0000

A high-severity vulnerability, identified as CVE-2026-50274, exists in the Datadog dd-trace-go tracing libraries, specifically versions 1.x (up to 1.24.1) and 2.x (up to 2.8.0). This flaw stems from improper parsing of incoming W3C baggage HTTP headers, where the libraries fail to enforce item-count or byte-size limits during the extraction process. The default limits (DD_TRACE_BAGGAGE_MAX_ITEMS=64, DD_TRACE_BAGGAGE_MAX_BYTES=8192) are only applied during baggage injection, not extraction. This oversight allows a remote, unauthenticated attacker to send specially crafted HTTP requests containing an arbitrarily large number of comma-separated key-value pairs or a single very large value within the baggage header. This malicious input causes the tracer to allocate an excessive number of hash-map entries for each request, leading to unbounded CPU and memory consumption, ultimately resulting in a Denial of Service (DoS) against any HTTP service instrumented with the affected tracer version where baggage propagation is enabled by default.

Attack Chain

An unauthenticated attacker crafts an HTTP request targeting an internet-facing service instrumented with a vulnerable dd-trace-go library.
The attacker includes a W3C baggage HTTP header in the request containing an exceptionally large number of comma-separated key-value pairs or a single, very large value.
The vulnerable dd-trace-go library, upon receiving the request, attempts to parse and extract the W3C baggage header.
Due to the lack of item-count or byte-size limits during extraction, the tracer allocates a hash-map entry for each key-value pair.
This unbounded allocation leads to significant and continuous increases in the service's CPU utilization and memory consumption.
The sustained resource exhaustion prevents the service from processing legitimate requests, resulting in a Denial of Service (DoS).

Impact

Successful exploitation of CVE-2026-50274 leads to a Denial of Service (DoS) condition on affected HTTP services. Attackers can remotely trigger unbounded CPU and memory consumption, causing the service to become unresponsive or crash. This impacts the availability of critical applications that rely on the dd-trace-go library for distributed tracing, potentially disrupting business operations and hindering monitoring capabilities. The vulnerability affects services that have baggage propagation style enabled by default or explicitly configured.

Recommendation

Patch CVE-2026-50274 immediately by upgrading dd-trace-go to version 2.8.1 or later. For those using dd-trace-go 1.x, the recommendation is to migrate to v2.8.1 or newer.
If immediate upgrade to dd-trace-go version 2.8.1 is not feasible, disable baggage extraction by removing baggage from the DD_TRACE_PROPAGATION_STYLE environment variable. Alternatively, if DD_TRACE_PROPAGATION_STYLE_EXTRACT is set independently, remove baggage from its value.
As an additional mitigation, cap the maximum HTTP request header size at an upstream proxy or web server. Refer to documentation for Apache (LimitRequestFieldSize), Nginx (large_client_header_buffers), or Envoy (max_request_headers_kb) to configure appropriate limits for HTTP header sizes.

Datadog dd-trace-js W3C Baggage Header Denial of Service Vulnerability

hello@craftedsignal.io — Wed, 15 Jul 2026 22:59:58 +0000

A high-severity Denial of Service (DoS) vulnerability, tracked as CVE-2026-50272, affects Datadog's dd-trace-js library in versions prior to 5.100.0. This flaw stems from the library's improper parsing of W3C baggage HTTP headers. While limits (DD_TRACE_BAGGAGE_MAX_ITEMS and DD_TRACE_BAGGAGE_MAX_BYTES) are enforced during baggage injection, they are not applied during extraction. This allows a remote, unauthenticated attacker to craft and send HTTP requests containing an arbitrarily large number of comma-separated key-value pairs or a single very large value within the baggage header. When a vulnerable service receives such a request, the dd-trace-js tracer attempts to allocate a hash-map entry for each pair, leading to unbounded consumption of CPU and memory resources, ultimately resulting in a Denial of Service. The baggage propagation style, which enables this vulnerability, is often enabled by default in affected tracers, making internet-facing services instrumented with these versions particularly susceptible.

Attack Chain

Attacker crafts malicious HTTP request: A remote, unauthenticated attacker constructs an HTTP request targeting an internet-facing service instrumented with dd-trace-js.
Injects oversized W3C baggage header: The attacker inserts a W3C baggage HTTP header into the request, containing an exceptionally large number of comma-separated key-value pairs or a single, extremely long value.
Request sent to vulnerable service: The malicious HTTP request is transmitted to the target service.
Vulnerable dd-trace-js receives request: The service, running a vulnerable version of dd-trace-js (prior to 5.100.0) with baggage propagation enabled by default, receives the request.
Improper header parsing occurs: The dd-trace-js library attempts to extract the baggage items from the oversized header without enforcing any item-count or byte-size limits on the extraction path.
Resource exhaustion: The library continuously allocates hash-map entries for each perceived key-value pair, leading to unbounded consumption of CPU and memory resources.
Denial of Service: The target service becomes unresponsive or crashes due to resource exhaustion, resulting in a Denial of Service for legitimate users.

Impact

Successful exploitation of CVE-2026-50272 leads to a Denial of Service (DoS) against HTTP services that are instrumented with vulnerable versions of the dd-trace-js library (prior to 5.100.0). Attackers can trigger this by sending a crafted HTTP request with an oversized W3C baggage header, causing the tracer to consume unbounded CPU and memory resources. This resource exhaustion can crash the targeted service, making it unavailable to legitimate users. Any internet-facing service utilizing the affected library with the baggage propagation style enabled (which is often the default configuration) is at risk, potentially leading to significant service disruption and operational downtime.

Recommendation

Upgrade the dd-trace-js library to version 5.100.0 or later immediately to patch CVE-2026-50272.
If immediate upgrade is not feasible, disable baggage extraction by modifying DD_TRACE_PROPAGATION_STYLE or DD_TRACE_PROPAGATION_STYLE_EXTRACT to remove baggage.
Implement upstream proxy or web server configurations to cap the maximum HTTP request header size. For example, configure Apache LimitRequestFieldSize, Nginx large_client_header_buffers, or Envoy max_request_headers_kb.

Datadog dd-trace-java DoS Vulnerability via W3C Baggage Headers

hello@craftedsignal.io — Wed, 15 Jul 2026 22:55:01 +0000

A high-severity denial-of-service vulnerability, tracked as CVE-2026-50270, affects Datadog's dd-trace-java library versions prior to 1.62.0. This flaw stems from improper parsing of W3C baggage HTTP headers without enforcing item-count or byte-size limits during the extraction process. While limits exist for baggage injection, they are not applied during extraction. A remote, unauthenticated attacker can exploit this by sending a specially crafted HTTP request containing an oversized or malformed W3C baggage header. This malicious header, when processed by the vulnerable tracer, triggers unbounded CPU and memory consumption as the library attempts to allocate hash-map entries for each of the numerous key-value pairs, leading to a denial of service against any internet-facing HTTP service instrumented with the affected dd-trace-java versions. W3C baggage propagation is often enabled by default, increasing the attack surface.

Attack Chain

An attacker identifies an internet-facing Java application instrumented with a vulnerable dd-trace-java version (prior to 1.62.0) that has W3C baggage propagation enabled.
The attacker crafts a malicious HTTP request, including a W3C baggage header containing an excessively large number of comma-separated key-value pairs or a single extremely long value.
The crafted HTTP request is sent by the attacker to the target application's exposed HTTP endpoint.
The vulnerable dd-trace-java library intercepts the incoming request and attempts to parse the malformed baggage header for distributed tracing propagation.
Due to the lack of item-count or byte-size limits on the extraction path, the library consumes an unbounded amount of CPU and memory resources while processing the oversized header.
This uncontrolled resource consumption leads to significant CPU utilization and memory exhaustion on the application server.
The server's resources are depleted, resulting in a denial-of-service condition, making the application unresponsive and unavailable to legitimate users.

Impact

The successful exploitation of CVE-2026-50270 results in a remote denial-of-service (DoS) against affected HTTP services. Attackers can render applications unresponsive and unavailable to legitimate users by consuming all available CPU and memory resources. Since the vulnerability is exploitable by remote, unauthenticated attackers, it poses a significant risk to any internet-facing service utilizing dd-trace-java versions prior to 1.62.0, especially when W3C baggage propagation is enabled by default. There are no reported specific victim counts or sectors, but any organization using the vulnerable library is at risk.

Recommendation

Upgrade the dd-trace-java library to version 1.62.0 or later immediately to patch CVE-2026-50270.
If immediate upgrade is not possible, disable baggage extraction by removing baggage from the DD_TRACE_PROPAGATION_STYLE environment variable (or DD_TRACE_PROPAGATION_STYLE_EXTRACT if set independently).
Implement maximum HTTP request header size limits at an upstream proxy or web server (e.g., Apache's LimitRequestFieldSize, Nginx's large_client_header_buffers, or Envoy's max_request_headers_kb) as a compensatory control against oversized W3C baggage headers.