Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach service with Jaeger propagator enabled
-
DeliveryCraft many/oversized uberctx-* baggage headers
-
Exploitextract() processes values without limits
-
ExecutionExcess CPU and heap allocation per request
-
ImpactSustained requests degrade availability
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation 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 | Requires the optional opentelemetry-propagator-jaeger package to be installed AND the Jaeger propagator to be explicitly enabled - it is not part of the default OpenTelemetry Python configuration - and the service must accept untrusted inbound propagation (uberctx-*) headers. Exploitation is practically limited by transport-level header constraints: Gunicorn's default 100 header fields and 8,190 bytes per field, and Uvicorn/h11's default 16,384-byte buffer, blunt the attack. Exposure is materially higher for non-HTTP transports, custom TextMapGetter implementations, or deployments where server/gateway header limits have been raised or disabled. Impact is confined to availability; no authentication is required per the CVSS vector (PR:N), but the deployment preconditions (AT:P) are the real gate. |
| Impact | This is a medium-severity availability-only issue (CWE-770, unbounded resource consumption) whose real-world priority is modest. The supplied CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N) scores 6.3 with impact limited to VA:L and zero confidentiality or integrity effect; notably AT:P flags that a specific attack requirement exists - namely that the optional Jaeger propagator be installed and enabled and that transport-level header limits be absent or raised. No EPSS score and no CISA KEV listing were provided, and no KEV or POC flag is set, so there is no public exploit identified at time of analysis. The vuln.today decision label is 'this_month' (not act_now/emergency), consistent with a patch-available, low-impact DoS rather than an urgent threat. The chief tension in the data is between the network-reachable, unauthenticated CVSS vector and the vendor's own statement that practical impact is limited: the opentelemetry-propagator-jaeger package must be installed separately, is not enabled by default, and common Python servers (Gunicorn: 100 header fields / 8,190 bytes each; Uvicorn/h11: 16,384-byte buffer) already constrain the input before it reaches the propagator. Net: a genuine but low-urgency, deployment-conditional availability bug - patch during routine maintenance rather than treat as a drop-everything priority. |
| Exploit ScenarioDerived | An attacker sends HTTP requests carrying numerous or oversized uberctx-* baggage headers to a service that has enabled the optional Jaeger propagator and accepts untrusted inbound propagation headers. JaegerPropagator.extract() processes every value with no per-entry, per-byte, or total-byte cap, forcing unnecessary CPU work and short-lived heap allocations per request; sustained requests contribute to denial of service where transport-level header limits are absent or raised. No public exploit code is identified; exploitation is most viable over non-HTTP transports, with custom TextMapGetter implementations, or where server/gateway header limits have been increased or disabled. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
Unbounded baggage processing in the optional OpenTelemetry Python Jaeger propagator (opentelemetry-propagator-jaeger before 1.45.0) lets a remote sender force unnecessary CPU work and short-lived heap allocations by supplying a carrier with numerous or oversized uberctx-* entries, degrading availability of the receiving service. According to the CVSS vector, no authentication is required (PR:N), but exploitation depends on specific deployment conditions (AT:P): the separately installed Jaeger propagator must be explicitly enabled - it is not part of the default OpenTelemetry Python configuration - and the service must accept untrusted inbound propagation headers. Practical impact is modest because common Python servers cap request headers before they reach the propagator (Gunicorn defaults to 100 header fields and 8,190 bytes per field; Uvicorn/h11 buffers incomplete events at 16,384 bytes), with materially higher exposure for non-HTTP transports, custom TextMapGetter implementations, or deployments that have raised or disabled server and gateway limits. No public exploit code has been identified at time of analysis, and the vendor has released a fix in 1.45.0.
RemediationAI
Vendor-released patch: upgrade opentelemetry-propagator-jaeger to version 1.45.0 or later - this is the complete fix, and it caps extraction at 180 entries and 8,192 total bytes while skipping entries larger than 4,096 bytes, with the same limits applied on inject (upstream PR #5556, commit 65c4eeb87cd3815dc795d3b5485e9ea0d5affcc7, release https://github.com/open-telemetry/opentelemetry-python/releases/tag/v1.45.0, advisory https://github.com/open-telemetry/opentelemetry-python/security/advisories/GHSA-f5m9-jfrj-jjj7). Where an immediate upgrade is not possible, the most effective compensating control is to leave the optional Jaeger propagator disabled and rely on the default propagator configuration, since the vulnerable code path only runs when JaegerPropagator is explicitly enabled - the trade-off is loss of legacy Jaeger uberctx-* baggage interoperability, though uber-trace-id trace context from non-upgraded senders is likewise no longer parsed. Additionally, keep transport-level header limits at or below their stock values (Gunicorn's default 100 header fields and 8,190 bytes per field, Uvicorn/h11's 16,384-byte buffer) rather than raising or disabling them, and review custom TextMapGetter implementations and non-HTTP transports, which bypass these server-side caps and therefore carry the greatest exposure; raising those limits widens the attack surface until the package is upgraded.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in pypi, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
OpenTelemetry's Jaeger propagator (opentelemetry-propagator-jaeger) implements the TextMapPropagator interface for the legacy Jaeger header format, parsing the uber-trace-id trace context and baggage carried in uberctx-* keys. CWE-770 (Allocation of Resources Without Limits or Throttling) applies because JaegerPropagator.extract() iterated every uberctx-* key returned by the configured getter and copied each value into the baggage map with no cap on entry count, per-entry byte size, or aggregate byte size - unlike the core W3CBaggagePropagator, which already enforced the W3C Baggage limits. Because the Jaeger format itself defines no baggage limits, the count of candidates inspected was effectively dictated by whatever the transport allowed through, so a carrier with many or very large values translated directly into parsing work and short-lived allocations per request. The upstream fix (PR #5556) borrows the W3C limits: MAX_BAGGAGE_ENTRIES = 180, MAX_BAGGAGE_ENTRY_BYTES = 4096 and MAX_BAGGAGE_TOTAL_BYTES = 8192, using itertools.islice so the cap bounds the candidates inspected rather than only the entries kept, dropping entries that exceed the per-entry byte budget, charging a separator byte between accepted entries, and applying the same limiting helper to inject() so an in-process baggage map cannot produce unbounded outbound headers. The impact is strictly availability-related: no telemetry data is exposed or modified and there is no code execution path. Note that the CVSS v4 vector's AT:P reflects the presence of deployment-specific preconditions rather than the trigger mechanism, and the sources do not describe any further trigger detail beyond the extraction loop reading uberctx-* values.
Know when Opentelemetry Python 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
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
Network, unauthenticated (PR:N), but exploitation depends on the optional propagator being enabled and header limits being absent/raised, so AC:H; availability-only, hence A:L and C/I:N.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
OpenTelemetry Python provides the Python API and SDK for OpenTelemetry. Prior to 1.45.0, JaegerPropagator.extract() in opentelemetry-propagator-jaeger processes inbound uberctx-* baggage values without entry, per-entry byte, or total-byte limits. Services that enable the optional Jaeger propagator can perform unnecessary CPU work and short-lived heap allocations when an untrusted carrier supplies numerous or oversized values, contributing to denial of service when transport-level limits do not constrain the input. Common default Python HTTP server limits reduce the practical impact, while custom getters, non-HTTP transports, or raised header limits increase exposure. This issue is fixed in version 1.45.0.
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.
EUVD-2026-111385
GHSA-f5m9-jfrj-jjj7
NVD
CVE.org
EPSS
Exploit-DB