CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-54712

CVE-2026-54712: Uncontrolled Resource Consumption in OpenTelemetry Javaagent RMI Context Propagation

Alon Barad
Alon Barad
Software Engineer

Jul 29, 2026·7 min read·88 visits

Executive Summary (TL;DR)

OpenTelemetry Javaagent prior to 2.27.0 allows unauthenticated remote attackers to trigger heap memory exhaustion and Denial of Service (DoS) by sending oversized RMI context propagation payloads.

An uncontrolled resource consumption vulnerability in the OpenTelemetry Javaagent RMI context propagation mechanism allows remote unauthenticated attackers to cause a Denial of Service (DoS) via heap memory exhaustion.

Vulnerability Overview

The OpenTelemetry Javaagent provides auto-instrumentation capabilities for Java applications, injecting tracing, metrics, and logging facilities into various frameworks without requiring manual code modifications. Within this ecosystem, Remote Method Invocation (RMI) instrumentation is utilized to capture and trace remote calls across JVM boundaries. To maintain trace context across these distributed boundaries, the agent intercepts incoming and outgoing RMI invocations to propagate context payloads containing trace IDs, span IDs, and associated metadata.

The vulnerability, tracked as CVE-2026-54712, resides in how the OpenTelemetry Javaagent deserializes incoming RMI context propagation payloads. Specifically, when an RMI endpoint is monitored by an instrumented Java Virtual Machine, the agent attempts to parse trace context from the incoming stream. If the network interface exposing the RMI service is reachable by an unauthenticated attacker, malicious payloads can be transmitted directly to the instrumentation layer.

This flaw belongs to the class of Uncontrolled Resource Consumption (CWE-400), which can lead to complete Denial of Service (DoS) of the underlying application. By abusing the context propagation parsing logic, a remote attacker can force the Java Virtual Machine to allocate an excessive volume of heap memory, triggering a java.lang.OutOfMemoryError (OOM) and terminating the host process.

Root Cause Analysis

The root cause of CVE-2026-54712 is a lack of validation on the cumulative size of strings deserialized from the RMI context propagation stream. Distributed tracing agents must reconstruct context state from serialized inputs. In vulnerable versions of the OpenTelemetry Javaagent (2.26.1 up to, but excluding, 2.27.0), the context deserialization logic is handled by the ContextPayload class, which extracts keys and values directly from an incoming object input stream.

While the implementation implemented a check on the total number of map entries (MAX_CONTEXT_ENTRIES set to 1000) to prevent CPU-based denial of service or hash collision attacks, it omitted any verification of the length of the individual strings. The deserialization loop sequentially reads string keys and values using the ObjectInput.readUTF() method. This method reads a length indicator from the stream and attempts to allocate and construct a corresponding Java String instance.

Because Java's readUTF() function supports strings up to 65,535 bytes in length, an attacker can supply 1,000 entries where every key and value is of maximum length. The JVM is then forced to allocate memory for 1,000 keys and 1,000 values, each close to 64 KB, within a single short-lived network transaction. This results in the allocation of approximately 131 megabytes of heap memory per malicious payload, bypassing the entry-count limit and exhausting system resources when multiple concurrent requests are processed.

Code Analysis

An analysis of the vulnerable source code in io.opentelemetry.javaagent.instrumentation.rmi.context.ContextPayload reveals the precise implementation weakness. The parsing mechanism reads an integer indicating the number of context entries, performs a simple boundary check against MAX_CONTEXT_ENTRIES, and then enters a loop to retrieve the string elements.

// Vulnerable Code Path (v2.26.1)
public static ContextPayload read(ObjectInput oi) throws IOException {
  int size = oi.readInt();
  if (size > MAX_CONTEXT_ENTRIES) { // Only limits entry count, not byte size
    logger.log(FINE, "RMI context propagation payload size {0} exceeds...", size);
    return null;
  }
  Map<String, String> map = new HashMap<>();
  for (int i = 0; i < size; i++) {
    String key = oi.readUTF(); // Allocates string up to 65535 characters
    String value = oi.readUTF(); // Allocates string up to 65535 characters
    map.put(key, value);
  }
  return new ContextPayload(map);
}

The patch implemented in version 2.27.0 introduces two defensive layers. First, the MAX_CONTEXT_ENTRIES limit is lowered from 1,000 to 100, which aligns the threshold with standard corporate limits such as Tomcat's maxHeaderCount. Second, a new constant MAX_CONTEXT_SIZE (8,192 characters) is introduced, and a running total of character allocations is accumulated during the loop.

// Patched Code Path (v2.27.0)
public static ContextPayload read(ObjectInput oi) throws IOException {
  int size = oi.readInt();
  if (size > MAX_CONTEXT_ENTRIES) { // MAX_CONTEXT_ENTRIES is now 100
    logger.log(FINE, "RMI context propagation entries count {0} exceeds...", size);
    return null;
  }
  int contextSize = 0;
  Map<String, String> map = new HashMap<>();
  for (int i = 0; i < size; i++) {
    String key = oi.readUTF();
    String value = oi.readUTF();
    contextSize += key.length() + value.length();
    if (contextSize > MAX_CONTEXT_SIZE) { // MAX_CONTEXT_SIZE is 8192
      logger.log(FINE, "RMI context propagation payload size exceeds maximum...");
      return null; // Triggers early abort
    }
    map.put(key, value);
  }
  return new ContextPayload(map);
}

> [!WARNING] > Note that this check is post-facto. The readUTF() call still instantiates the String object into memory before its length is checked. While this prevents the massive accumulation across 100 entries, an attacker can still force the allocation of a single pair of large strings on the first iteration before the limit is exceeded. This minimal residual risk is unlikely to cause a Denial of Service unless executed under highly concurrent conditions.

Exploitation Methodology

Exploiting CVE-2026-54712 requires network line-of-sight to an RMI endpoint exposed by an application running the vulnerable OpenTelemetry Javaagent. Since RMI registries usually listen on default TCP ports such as 1099 or 1098, an attacker begins by identifying accessible RMI services on the target network. Authentication is not required because context propagation is intercepted and processed prior to standard application-level authentication checks.

To construct an exploit, a client sends standard RMI call structures containing a serialized ContextPayload object. The payload is carefully formatted to set the entry count integer to a value just below the validation threshold (e.g., 1000 for vulnerable versions). Each map entry is populated with long dummy string parameters composed of repeating characters to maximize payload volume while keeping computational overhead low.

When the agent receives the RMI packet, it invokes the deserialization routine. The JVM attempts to parse and instantiate the strings on the heap. Because multiple threads often process concurrent RMI calls, a sustained transmission of these oversized packets causes rapid heap consumption. The garbage collector becomes overwhelmed, leading to thread starvation, application unresponsiveness, and an eventual crash due to a java.lang.OutOfMemoryError.

Impact Assessment

The technical impact of CVE-2026-54712 is a complete loss of availability for the affected Java Virtual Machine. While CVSS v3.1 rates the availability impact as 'Low' (yielding a base score of 5.3), in practical enterprise scenarios, an unhandled java.lang.OutOfMemoryError typically leads to JVM crash or freeze. The process is either terminated by the operating system kernel (OOM Killer) or enters a state of perpetual garbage collection thrashing, rendering the service entirely unresponsive.

Because this vulnerability occurs within the auto-instrumentation agent itself, it affects any downstream application that relies on the agent for monitoring, regardless of whether the business logic itself utilizes RMI. If the target application exposes RMI endpoints for administrative tasks, JMX monitoring, or legacy middleware communications, the entire application becomes vulnerable to remote, unauthenticated disruption.

No confidentiality or integrity impacts are associated with this flaw. The exploit vector is strictly restricted to resource exhaustion and does not allow for remote code execution (RCE) or information disclosure. The vulnerability lacks an active exploitation record in the CISA KEV catalog, and EPSS scores suggest low exploitation probability in standard enterprise networks due to the declining prevalence of externally exposed RMI services.

Remediation and Mitigation

Remediation requires upgrading the OpenTelemetry Javaagent to version 2.27.0 or higher. This release integrates strict cumulative size boundaries during RMI context parsing, ensuring that any payload exceeding 8,192 characters is rejected immediately, thereby mitigating the risk of heap exhaustion.

If upgrading is not immediately feasible, organizations can implement workarounds to eliminate the attack surface. The most effective workaround is to disable the RMI instrumentation module entirely. This can be accomplished by setting the environment variable OTEL_INSTRUMENTATION_RMI_ENABLED=false or passing the system property -Dotel.instrumentation.rmi.enabled=false at JVM startup.

Additionally, robust network access control lists (ACLs) should be deployed to prevent external networks from accessing RMI registries and communication ports (typically TCP 1099, 1098, and transient dynamic ports). Standard security best practices dictate that RMI and JMX services should never be exposed to the public internet or untrusted zones.

Technical Appendix

CVSS Score
5.3/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
EPSS Probability
0.26%
Top 82% most exploited

Affected Systems

OpenTelemetry JavaagentOpenTelemetry Java Instrumentation

Affected Versions Detail

Product
Affected Versions
Fixed Version
OpenTelemetry Java Instrumentation
OpenTelemetry
>= 2.26.1, < 2.27.02.27.0
AttributeDetail
CWE IDCWE-400
Attack VectorNetwork (AV:N)
CVSS v3.1 Score5.3 (Medium)
Vulnerability TypeUncontrolled Resource Consumption
Exploit StatusProof-of-Concept
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1499Endpoint Denial of Service
Impact
CWE-400
Uncontrolled Resource Consumption

The product does not properly control the allocation and maintenance of a limited resource, enabling an actor to influence the amount of resources consumed, leading to eventual exhaustion.

Vulnerability Timeline

Lauri Tulmin commits the fix restricting RMI context limits.
2026-04-17
GitHub Security Advisory and CVE-2026-54712 published.
2026-07-01
NVD assigns severity metrics to CVE-2026-54712.
2026-07-01

References & Sources

  • [1]GHSA-fq3f-m5qm-99f5: Uncontrolled Resource Consumption in OpenTelemetry Javaagent RMI Context Propagation
  • [2]Remediation Patch Pull Request (#17870)
  • [3]Remediation Commit (6ef1880)
  • [4]Official Release v2.27.0
  • [5]NVD Official Vulnerability Record (CVE-2026-54712)
  • [6]CVE.org Authoritative Vulnerability Detail

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•38 minutes ago•CVE-2026-126295
7.1

CVE-2026-126295: Path Traversal and Unconfined File Access in NLTK BllipParser

CVE-2026-126295 (also tracked as GHSA-fg9w-wfp5-j933) is a path confinement bypass vulnerability in the Natural Language Toolkit (NLTK) affecting versions 3.10.0 prior to 3.10.4. The flaw resides in nltk/parse/bllip.py within the BllipParser class and its factory method BllipParser.from_unified_model_dir(). Unlike sibling tool wrappers in NLTK that enforce data-root confinement via the nltk.pathsec module, BllipParser passes caller-supplied filesystem paths directly into the third-party bllipparser native C extension without validation. When an application passes untrusted input as model paths or directories to BllipParser, an attacker can force the native extension to open arbitrary files on the local filesystem. This leads to information disclosure through parser diagnostic oracles, local model tampering via shared directories, and denial of service by hanging worker threads on blocking special files (such as FIFOs or device nodes) or exhausting memory via oversized files.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 2 hours ago•CVE-2026-126300
5.3

CVE-2026-126300: Algorithmic Complexity Denial of Service in NLTK TreebankWordTokenizer.span_tokenize

CVE-2026-126300 (GHSA-ffr9-mgrr-wcvr) is an inefficient algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) Python library affecting versions 3.2.5 prior to 3.10.4. The flaw resides in the quote-restoration routine of TreebankWordTokenizer.span_tokenize and NLTKWordTokenizer.span_tokenize, where repeated calls to list.pop(0) over matched quote tokens introduce quadratic O(n^2) time complexity. An unauthenticated remote attacker who supplies input containing long sequences of double-quote characters can exhaust CPU resources and degrade service availability.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 3 hours ago•GHSA-GPWC-27CW-RH9R
5.3

CVE-2026-126301: Quadratic CPU Exhaustion in NLTK LegalitySyllableTokenizer

The Natural Language Toolkit (NLTK) versions 3.6 through 3.10.3 contain an algorithmic complexity vulnerability in the LegalitySyllableTokenizer.tokenize method. When processing tokens composed of continuous runs of vowels, an unguarded string reversal and set membership lookup loop executes in quadratic time relative to the input token length. Remote attackers capable of submitting arbitrary text to applications utilizing this tokenizer can trigger sustained single-core CPU exhaustion and application-level denial of service.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 4 hours ago•CVE-2026-126304
8.7

CVE-2026-126304: Symlink Path Traversal in NLTK YCOECorpusReader

CVE-2026-126304 is a symlink path traversal vulnerability (CWE-59) in the Natural Language Toolkit (NLTK) versions 3.10.0 prior to 3.10.4. The YCOECorpusReader class constructs internal sub-readers for the 'psd' and 'pos' subdirectories using FileSystemPathPointer.join(), which relies exclusively on lexical string-prefix validation rather than canonical path resolution. An attacker who supplies a crafted YCOE corpus containing symbolic links in place of the 'psd' or 'pos' subdirectories can bypass directory confinement and read arbitrary files from sibling corpora or sensitive directories within the NLTK data sandbox.

Amit Schendel
Amit Schendel
6 views•9 min read
•about 5 hours ago•CVE-2026-128077
6.5

CVE-2026-128077: Authorization Bypass via Request Path Desynchronization in Nuxt and @nuxt/nitro-server

CVE-2026-128077 (GHSA-r99w-jh2x-3mg9) is an authorization bypass and interpretation conflict vulnerability affecting Nuxt and its underlying @nuxt/nitro-server package in versions 4.6.0 through 4.6.3. When an incoming HTTP request path begins with a double forward slash (e.g., //x/admin), the WHATWG URL parser within the Nuxt server-side page renderer interprets the initial segment as a network host/authority and resolves the remaining path (/admin) against the application's page router. Because Nitro server middleware, route-scoped serverHandlers, and Nitro routeRules evaluate the unparsed request path (//x/admin), path-based access controls, redirects, and security header policies configured for /admin fail to match and are bypassed.

Amit Schendel
Amit Schendel
5 views•10 min read
•about 6 hours ago•CVE-2026-128084
4.8

CVE-2026-128084: Integer Truncation and SQL Query Truncation in sqlite3-ruby

Prior to version 2.10.2, the sqlite3-ruby gem explicitly cast 64-bit Ruby string lengths (long) to 32-bit signed integers (int) when invoking the underlying SQLite C API. On 64-bit platforms, providing a string of 4 GiB (2^32 bytes) or larger causes integer truncation, instructing SQLite to process only a prefix of the string. This flaw affects SQL query preparation, bound parameter values, and return values from custom Ruby-defined SQL functions and aggregates, allowing trailing SQL clauses such as WHERE restrictions to be silently dropped under specific conditions.

Alon Barad
Alon Barad
5 views•11 min read