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



GHSA-47QP-HQVX-6R3F

GHSA-47QP-HQVX-6R3F: Remote Memory Exhaustion (Denial of Service) in JLine3 Telnet Server

Amit Schendel
Amit Schendel
Senior Security Researcher

Jun 18, 2026·7 min read·88 visits

Executive Summary (TL;DR)

Unauthenticated remote attackers can crash the JLine3 Telnet server via memory exhaustion by transmitting unbounded NEW-ENVIRON variables during protocol negotiation.

An unauthenticated remote memory exhaustion vulnerability in the JLine3 Telnet server allows attackers to crash the host Java Virtual Machine (JVM). The flaw exists in the processing of the NEW-ENVIRON option, where the server accepts an arbitrary number of environment variables without limits, storing them in an unconstrained HashMap. Sending as little as 3.25 MB of payload data can exhaust a standard JVM heap and trigger an OutOfMemoryError. This vulnerability affects applications integrating the remote-telnet module of JLine3.

Vulnerability Overview

The JLine3 project is a Java library designed for handling console input. Its remote terminal capabilities include an integrated Telnet server implementation provided by the org.jline:jline-remote-telnet artifact. This server enables administrators or applications to expose a command-line interface over a TCP port, mimicking a legacy multi-user environment.

During the initial connection phase, the Telnet server handles protocol negotiation via command sequences. This phase occurs before authentication. This design exposes a significant attack surface because any network-facing client can interact with the negotiation parser. The vulnerability lies within the handling of the environment variable configuration option defined in RFC 1572.

Specifically, the server processes incoming environment variables and allocates storage space on the Java virtual machine heap for each pair. Because this parsing engine does not impose boundaries on the quantity of variables, an unauthenticated client can trigger uncontrolled memory allocation. The result is a total denial of service due to memory exhaustion.

Root Cause Analysis

The root cause of the vulnerability lies in the lack of collection bounds and state validation during the Telnet NEW-ENVIRON option negotiation. The NEW-ENVIRON protocol (RFC 1572) is designed to allow a client to advertise local environment variables to the server using subnegotiation payloads. The server parses these variables and associates them with the session configuration via the ConnectionData context.

In the vulnerable implementation, the connection metadata manages environment variables within a standard HashMap<String, String> initialized with a default capacity of 20 entries. While the parser imposes length limits on individual variable names (50 characters) and variable values (1000 characters), it completely lacks limits on the aggregate count of elements. This missing architectural constraint allows the HashMap to grow dynamically without restriction.

An attacker can exploit this design by transmitting a continuous, unbounded stream of subnegotiation variables. Because the server parses these sequentially from the raw network socket block inside a loop, it creates new String objects and map nodes for every incoming element. The connection thread remains active and continues reading from the input stream, continuously growing the HashMap until the heap capacity of the JVM is depleted.

Code Analysis

To understand the vulnerability, consider the original implementation of the environment negotiation processing loop in TelnetIO.java prior to the fix. The parsing loop runs iteratively without maintaining a tracking index of processed variables:

// Vulnerable Code Path in TelnetIO.java
boolean cont = true;
if (i == NE_VAR || i == NE_USERVAR) {
    do {
        switch (readNEVariableName(sbuf)) {
            case NE_VAR_OK:
                // Inserts directly into the session environment HashMap
                TelnetIO.this.connectionData.getEnvironment().put(str, sbuf.toString());
                break;
            case NE_VAR_UNDEFINED:
                break; 
        }
    } while (cont);
}

The cont flag remains true during the entire lifecycle of the subnegotiation block, and the parsing process only terminates if an error or explicit completion signal occurs. Since the JVM allocates substantial memory headers for each HashMap entry—including Map.Entry wrappers, key/value string object references, and the underlying backing array expansion—small payloads result in high memory overhead.

The remediation introduced by Guillaume Nodet in commit 934f09e6128cee33c2b13d42b6e859c1ee2d194b addresses this issue by declaring a static constraint NE_VAR_COUNT_MAX = 100 and tracking loop iterations:

// Patched Code Path in TelnetIO.java
protected static final int NE_VAR_COUNT_MAX = 100; // Security boundary
 
// ... inside readNEVariables() ...
int varCount = 0; // Local counter
boolean cont = true;
if (i == NE_VAR || i == NE_USERVAR) {
    do {
        switch (readNEVariableName(sbuf)) {
            case NE_VAR_DEFINED:
                LOG.log(Level.DEBUG, "readNEVariables()::NE_VAR_DEFINED");
                if (++varCount > NE_VAR_COUNT_MAX) {
                    // Limit exceeded, logging warning and aborting
                    LOG.log(Level.WARNING, "readNEVariables()::TOO_MANY_VARS (>" + NE_VAR_COUNT_MAX + ")");
                    skipToSE(); // Flush the socket stream safely
                    return;     // Reject further variables
                }
                String str = sbuf.toString();
                // ... remainder of parsing logic ...

This modification enforces a hard ceiling on the number of environment variables accepted during negotiation. If the counter exceeds 100, the parser logs an entry, uses skipToSE() to advance the network stream pointer past the remaining subnegotiation data to prevent desynchronization, and aborts execution. This stops heap exhaustion attempts before they can impact JVM availability.

Exploitation

Exploiting this vulnerability does not require any credentials or pre-authentication steps. The negotiation stage of the Telnet protocol occurs before the user is prompted for credentials or presented with a login shell. An attacker only needs a route to establish a TCP connection to the active Telnet listener.

The attack begins with standard TCP handshake completion. The server offers capability negotiations, including the NEW-ENVIRON option. Once the client indicates support, the server issues a request for environment variables: IAC SB NEW-ENVIRON SEND IAC SE (represented in hex as \xff\xfa\x27\x01\xff\xf0). The attacker responds with an environment data declaration prefix: IAC SB NEW-ENVIRON IS (\xff\xfa\x27\x00).

Instead of terminating the block with the closing command sequence IAC SE (\xff\xf0), the attacker sends a dense, continuous sequence of simulated environment variables. For example, the payload alternates variable declaration types with incrementing byte sequences representing names and values. The parser reads these tokens and populates the JVM heap.

Because of the overhead of Java String allocations, generating 250,000 map entries is sufficient to consume approximately 500 MB of heap. At 13 bytes per variable on the wire, this requires approximately 3.25 MB of payload data. The attack completes quickly and degrades JVM performance until the hosting process crashes.

Impact Assessment

The vulnerability has a CVSS v3.1 base score of 7.5, reflecting its high impact on application availability. Because JLine3 is designed as an embedded library, the Telnet service runs within the same JVM process as the parent application. Consequently, triggering an OutOfMemoryError in the Telnet thread leads to complete failure of the host process.

The exploitation of this bug results in a full Denial of Service (DoS). The affected system stops responding to remote requests, and any concurrent sessions or unrelated internal operations within the JVM are terminated. In multi-tenant systems or cloud microservices, this can cause cascade failures across related services.

Because this vulnerability requires no authentication and can be triggered via a low-bandwidth stream, it is a highly reliable target for denial of service attacks. However, it cannot be leveraged for remote code execution (RCE) or data confidentiality bypasses. The impact is limited to system availability.

Remediation & Detection

The primary remediation strategy is upgrading the dependency org.jline:jline-remote-telnet to version 4.2.1 or newer. This update integrates the boundary enforcement fix and limits accepted environment variables to 100 per session.

If patching is delayed, administrators should restrict exposure using firewalls or network access control lists (ACLs). Access to the Telnet port must be restricted to trusted, internal IP addresses. Alternatively, if Telnet management is not a business requirement, the module should be disabled entirely.

Detection can be implemented via network-based intrusion detection systems (IDS). Security engineers can deploy custom Snort or Suricata rules to inspect Telnet streams. A rule should watch for long, unbroken sequences of variable negotiation identifiers (\xff\xfa\x27\x00) that exceed normal length thresholds without a corresponding closing sequence (\xff\xf0).

Fix Analysis (1)

Technical Appendix

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

Affected Systems

Applications employing JLine3 Telnet server module (jline-remote-telnet)

Affected Versions Detail

Product
Affected Versions
Fixed Version
jline-remote-telnet
JLine
< 4.2.14.2.1
AttributeDetail
CWE IDCWE-400
Attack VectorNetwork (AV:N)
CVSS Base Score7.5
EPSS ScoreNot Available
ImpactDenial of Service / JVM Crash
Exploit StatusPoC (Proof of Concept)
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1499Endpoint Denial of Service
Impact
T1499.004Application Exhaustion
Impact
CWE-400
Uncontrolled Resource Consumption

The software does not control, or improperly controls, the allocation and maintenance of a limited resource, enabling an actor to cause resource exhaustion.

References & Sources

  • [1]GitHub Advisory for GHSA-47QP-HQVX-6R3F
  • [2]Fix Commit in GitHub Repository

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

•1 day ago•CVE-2026-128087
3.7

CVE-2026-128087: Premature Key Exchange Callback Invocation Prior to Host Key Verification in russh

CVE-2026-128087 (GHSA-9264-jvgf-6w2f) is an incorrect behavior order (CWE-696) and improper authorization (CWE-863) vulnerability in the russh Rust SSH library, affecting versions 0.55.0 through 0.65.0. During the initial SSH key exchange (KEX) handshake, the client state machine invokes the client::Handler::kex_done() callback—providing the negotiated raw shared secret bytes—prior to validating the remote server's host key or certificate via check_server_key(). Consequently, an untrusted or rogue SSH server can complete cryptographic key agreement and force a connecting client to execute side-effecting application logic inside kex_done() before the server's identity is checked and rejected.

Amit Schendel
Amit Schendel
8 views•10 min read
•2 days ago•CVE-2026-128082
7.5

CVE-2026-128082: Uncontrolled Recursion and Denial of Service in AutoMapper via Constructor Parameter Mapping

CVE-2026-128082 (GHSA-6vhm-j9h7-f9gh) is an uncontrolled recursion vulnerability (CWE-674) in AutoMapper, a convention-based object-object mapper for .NET. When mapping nested or self-referential types into destination models that rely on parameterized constructors, C# positional records, or recursive ConstructUsing expressions, AutoMapper evaluates child constructor arguments prior to incrementing the parent's recursion depth counter. This ordering flaw bypasses both explicit MaxDepth limits and the default depth limit of 64. An unauthenticated remote attacker can supply deeply nested input payloads to affected endpoints, exhausting the thread call stack and triggering an uncatchable System.StackOverflowException that terminates the hosting .NET process.

Amit Schendel
Amit Schendel
8 views•11 min read
•2 days ago•CVE-2026-128080
5.8

CVE-2026-128080: Sensitive Query Parameter Disclosure on Incoming Server Spans in OpenTelemetry JavaScript (@opentelemetry/instrumentation-http)

An information exposure vulnerability in the @opentelemetry/instrumentation-http package for OpenTelemetry JavaScript versions 0.204.0 prior to 0.222.0 causes incoming HTTP server spans to record raw, unredacted query string parameters under the url.query attribute. While outgoing client spans applied built-in and user-configured query parameter redaction, incoming server spans bypassed this sanitization completely, resulting in the transmission of sensitive credentials such as pre-signed cloud URLs and API tokens to external observability backends.

Alon Barad
Alon Barad
7 views•10 min read
•2 days ago•CVE-2026-128089
7.5

CVE-2026-128089: Uncontrolled Resource Consumption in dnspython WKS Record Parser

CVE-2026-128089 is an uncontrolled resource consumption vulnerability in the dnspython toolkit for Python, affecting all versions prior to 2.9.2. When parsing Well-Known Service (WKS) records from text via dns.rdtypes.IN.WKS.WKS.from_text(), the parser fails to validate that numeric service port identifiers fall within the RFC 1035 valid range of 0 through 65535. An attacker capable of supplying untrusted zone files or RDATA text strings containing an arbitrarily large service port integer can force the parser to allocate an unbounded bitmap array using an inefficient linear append loop, resulting in severe CPU exhaustion, application hangs, or Out-Of-Memory (OOM) process termination.

Amit Schendel
Amit Schendel
8 views•10 min read
•2 days ago•CVE-2026-126347
3.1

CVE-2026-126347: Open Redirect via Triple-Slash Redirect Paths in Tornado RedirectHandler

CVE-2026-126347 (GHSA-5cjw-f85j-cv6r) is an open redirect vulnerability (CWE-601) in Tornado, an asynchronous Python networking library and web framework. The flaw resides in tornado.web.RedirectHandler when dynamic URL redirection templates incorporate unvalidated user input. Due to a parser differential between RFC 3986 (used by Python's urllib.parse.urlsplit) and the WHATWG URL Standard (used by modern web browsers), inputs containing three or more leading slashes bypass Tornado 6.6.0's validation logic, allowing unauthenticated attackers to redirect users to arbitrary external domains.

Alon Barad
Alon Barad
8 views•11 min read
•2 days ago•CVE-2026-128123
5.9

CVE-2026-128123: Uncaught Exception and Denial of Service in SvelteKit @sveltejs/adapter-node

A Denial of Service (DoS) vulnerability exists in @sveltejs/adapter-node versions 5.5.7 and 6.0.0-next.0 through 6.0.0. When a SvelteKit server route returns a direct response from a fetch() call with a Content-Type of text/event-stream, the Node.js adapter attempts to mutate the response headers to disable proxy buffering. Because headers returned directly by the WHATWG Fetch API carry an immutable guard, this mutation throws an unhandled TypeError, terminating the underlying Node.js process and denying service to all active and subsequent clients.

Alon Barad
Alon Barad
8 views•9 min read