maven package report

Is io.opentelemetry:opentelemetry-extension-trace-propagators safe?

1 known vulnerability, worst severity MODERATE.

// reach

0 direct dependencies

none carry a known advisory

    0 packages depend on it

    an advisory here reaches each of them

      Create a free accountfor every dependency path, dependent and what to upgrade
      // ai model usage

      Tracked for PyPI packages. HuggingFace models declare Python dependencies, so maven packages are not covered.


      cvss
      0.0
      high

      severity out of 10

      epss
      0.00%
      medium

      chance of exploitation in 30 days, 56th percentile of all CVEs

      xyz score
      not scored

      CyberXYZ composite out of 10

      fig. 01 — GHSA-rcgg-9c38-7xpx, the advisory selected below

      // 1 advisories

      GHSA-rcgg-9c38-7xpx

      MODERATECVE-2026-45292
      // overview

      A vulnerability affects the baggage propagation implementation in opentelemetry-api and opentelemetry-extension-trace-propagators. Parsing oversized baggage causes unbounded memory allocation and CPU consumption. Because baggage is automatically re-injected into every outgoing request, the effect can fan out to downstream services that never received the original malicious request.

      // technical details
      • W3CBaggagePropagator did not enforce any limit on the total size or entry count of the

      baggage header. The parser iterated character-by-character through the entire value regardless of length.

      • JaegerPropagator and OtTracePropagator had the same gap in their respective baggage

      extraction paths.

      • The W3C Baggage specification recommends a maximum of 8,192 bytes and 180 entries; none of

      these limits were enforced.

      // impact

      The practical availability impact for most deployments is limited. Every major Java HTTP server enforces its own header size limit (Tomcat, Jetty, Netty, Vert.x, and gRPC-Java all default to 8 KiB), constraining what an external attacker can deliver before the application is reached. The risk is higher when transport-layer limits are absent — e.g., a compromised internal service communicating over a non-HTTP or custom transport.

      // remediation

      Update to version 1.62.0 or later (#8380). The fix enforces limits consistent with the W3C Baggage specification at the propagator level:

      • Maximum total baggage size: 8,192 bytes across all baggage header values
      • Maximum number of entries: 64

      Headers that would exceed either limit are dropped at the point the limit is reached; already-extracted valid entries are retained.

      // workarounds

      Ensure HTTP header size limits are configured at the server or gateway level. Most Java HTTP servers enforce an 8 KiB header limit by default, which mitigates external attack vectors independently of this fix.

      // references
      // cvss v3.1 vector

      CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

      Attack vector
      Network
      Attack complexity
      Low
      Privileges required
      None
      User interaction
      None
      Scope
      Unchanged
      Confidentiality
      None
      Integrity
      None
      Availability
      High

      Checked 2026-09-26 at 01:06 UTC. The most recent advisory here was published 2026-05-14. Updated continuously from NVD, GHSA, OSV and CNA feeds.

      Think a verdict here is wrong? Tell us — we respond within 2 business days.