Skip to main content

OpenTelemetry Python EUVDEUVD-2026-111385

| CVE-2026-116694 MEDIUM
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-10-27 GitHub_M GHSA-f5m9-jfrj-jjj7
6.3
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Reach service with Jaeger propagator enabled
  2. Delivery
    Craft many/oversized uberctx-* baggage headers
  3. Exploit
    extract() processes values without limits
  4. Execution
    Excess CPU and heap allocation per request
  5. Impact
    Sustained 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.4% exploitation probability (EPSS)

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

Alert me

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

opentelemetry-python < 1.45.0

Affected Packages

pypi opentelemetry-propagator-jaeger fix: 1.45.0
euvd opentelemetry_python fix: 1.45.0

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

Vendor (GitHub_M) PRIMARY 6.3 MEDIUM
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
vuln.today AI 3.7 LOW

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.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

1
Patch available
Oct 27, 2026 - 21:18 EUVD

DescriptionCVE.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

EPSS Score
0.4%
Top 68% exploitable
Prevalence
Medium
optional Jaeger propagator, installed and enabled separately, not default
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
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 MEDIUM
CISA KEV No
Public POC Yes
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
Poc
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact· derived
Medium

Priority Score

52
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +32
PoC: +20
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.

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