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-54609

CVE-2026-54609: Uncontrolled Resource Consumption and Network Amplification in QTINeon

Amit Schendel
Amit Schendel
Senior Security Researcher

Jul 28, 2026·5 min read·39 visits

Executive Summary (TL;DR)

An unauthenticated remote attacker can exploit the QTINeon reconnect handler to exhaust relay server memory and launch network amplification attacks against target game hosts.

Quiet-Terminal-Interactive's QTINeon version 1.0.0 is vulnerable to uncontrolled resource consumption and relay-to-host network amplification. The reconnect request handler lacks table size constraints, rate limiting, and request deduplication, allowing unauthenticated attackers to crash the relay server and overwhelm target hosts.

Vulnerability Overview

QTINeon is a game-agnostic, relay-based UDP multiplayer protocol library developed by Quiet-Terminal-Interactive. In its architecture, the relay server facilitates connections between remote clients and the game host, bypassing NAT restrictions and hiding the host's direct IP address. The system relies on specific UDP packet headers to manage state transitions, including session establishment and reconnections.

Version 1.0.0 of the library exposes an unprotected reconnect flow that can be targeted by remote attackers. While primary connection handshakes implement rate limits and table size constraints, the reconnect request handler lacks these essential security controls. This deficiency introduces a direct path to denial of service through memory exhaustion and packet forwarding amplification.

Root Cause Analysis

The underlying flaw resides within the reconnect processing mechanism, specifically the handleReconnectRequest function. When a client drops offline or attempts to resume an active session, it transmits a RECONNECT_REQUEST packet to the relay. The relay processes this request by registering it inside an internal mapping table named pendingReconnects to track the state of active handshakes.

Two critical flaws are present in this implementation. First, the pendingReconnects map does not enforce a maximum size boundary, meaning the server continues to allocate memory for every unique request it receives. Second, the handler performs no deduplication or rate limiting on incoming client identifiers, allowing a single sender to flood the server and force continuous map insertions.

As a consequence of these design gaps, the relay immediately routes every processed reconnect packet to the game host. The host is forced to process an unthrottled volume of handshakes, leading to system resource exhaustion.

Code Analysis

The following code block demonstrates the difference between the vulnerable implementation in version 1.0.0 and a secure implementation that mitigates the resource allocation and forwarding flaws.

// VULNERABLE: Version 1.0.0 lack of size constraints and validation
public void handleReconnectRequest(ReconnectPacket packet, IPEndPoint clientEndPoint) {
    // No check on pendingReconnects dictionary size
    // No deduplication or validation of packet details
    pendingReconnects[packet.ClientId] = new ReconnectState(packet, DateTime.UtcNow);
    
    // Direct forwarding to host without rate limiting or validation
    ForwardToHost(packet);
}

To remediate this, developers must manually add size-limiting guard clauses, request deduplication, and a timer-based pruning task. The secure pattern checks map thresholds and discards duplicate requests before allocating memory or forwarding traffic.

// SECURE: Implementing bounds checking, deduplication, and rate controls
private const int MaxPendingReconnects = 1024;
 
public void handleReconnectRequest(ReconnectPacket packet, IPEndPoint clientEndPoint) {
    // 1. Enforce size limit to prevent memory exhaustion
    if (pendingReconnects.Count >= MaxPendingReconnects) {
        return;
    }
    
    // 2. Prevent duplicate entries from the same client ID
    if (pendingReconnects.ContainsKey(packet.ClientId)) {
        return;
    }
    
    // 3. Track state with timestamp for automatic expiration
    pendingReconnects[packet.ClientId] = new ReconnectState(packet, DateTime.UtcNow);
    
    // 4. Forward with rate limiting applied
    ForwardToHostWithRateLimit(packet);
}

Exploitation

Exploitation of CVE-2026-54609 requires network access to the UDP port exposed by the QTINeon relay server. An attacker does not require authentication or valid session credentials to interact with the reconnect handler. By generating spoofed UDP packets containing a structured RECONNECT_REQUEST header, the attacker initiates the exploit.

The attacker sends a stream of unique client reconnect requests at a rapid rate. Each packet causes the relay to allocate dynamic memory for a new session structure in the pendingReconnects map. Within seconds, this unconstrained allocation consumes the available memory on the relay host, causing the process to terminate due to out-of-memory errors.

Simultaneously, the relay server acts as an amplifier by forwarding each packet to the target game host. Because the host must process every handshake attempt originating from the trusted relay, its network interface and processor become saturated, disconnecting legitimate players.

Impact Assessment

The security impact of this vulnerability is scored at 8.6 on the CVSS scale, indicating high severity. The CVSS vector highlights that the attack can be executed remotely with low complexity and no privileges. The scope is changed because exploiting the relay server directly impacts the availability of the game host.

Successful exploitation results in a complete denial of service for both the relay and the backend game host. The relay process suffers from memory exhaustion, while the game host experiences network bandwidth saturation and CPU exhaustion. There is no impact on confidentiality or integrity, as the vulnerability does not allow unauthorized data access or modifications.

Remediation

No official patch is currently available for QTINeon version 1.0.0. Organizations deploying this library must implement custom code-level fixes to defend their infrastructure. The primary remediation strategy is the introduction of a maximum capacity constraint on the pendingReconnects mapping table.

Additionally, developers must implement a scheduled pruning routine that automatically evicts handshake entries older than 5 to 10 seconds. Network administrators should deploy rate-limiting rules on routers or firewalls to limit incoming UDP traffic on the relay's service port. Implementing IDS signatures to detect anomalous rates of reconnection request patterns is also recommended.

Technical Appendix

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

Affected Systems

QTINeon UDP Relay Server

Affected Versions Detail

Product
Affected Versions
Fixed Version
QTINeon
Quiet-Terminal-Interactive
== 1.0.0None
AttributeDetail
CWE IDCWE-400
Attack VectorNetwork (AV:N)
CVSS Score8.6
ScopeChanged (S:C)
ImpactAvailability (A:H)
Exploit Statusnone
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1499Endpoint Denial of Service
Impact
T1498Network 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 cause resource exhaustion.

Vulnerability Timeline

Vulnerability identified and disclosed via GitHub Security Advisory
2026-03-02

References & Sources

  • [1]GitHub Security Advisory (GHSA)
  • [2]CVE Record on CVE.org

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

•5 minutes ago•CVE-2026-129237
5.4

CVE-2026-129237: Partial Path Traversal (Zip Slip) in qbee-agent Tar Extractor

CVE-2026-129237 is a partial path traversal (Zip Slip) vulnerability in qbee-agent, the device agent for the qbee.io IoT device management platform. Prior to version 2026.41, the tar archive extraction routine in app/utils/tar.go used strings.HasPrefix without enforcing a directory separator boundary. When the Docker Compose bundle configuration has UseContext enabled, an authenticated user with delegated configuration or file management privileges can supply a crafted tar archive containing sibling-prefix traversal sequences, allowing directory creation and file writes into adjacent sibling directories outside the intended extraction root.

Alon Barad
Alon Barad
0 views•11 min read
•about 1 hour ago•CVE-2026-128118
7.5

CVE-2026-128118: Server-Only Module Guard Bypass and Secret Exposure in SvelteKit

CVE-2026-128118 (GHSA-m9j8-jcmv-hp69) is an information disclosure vulnerability affecting the SvelteKit framework (@sveltejs/kit) from version 3.0.0 through 3.1.0. A design flaw in the build-time Vite module guard plugin (plugin_guard) failed to register src/params.js as a client entry point and implemented a fail-open validation model. Consequently, server-only modules and private environment variables imported directly or dynamically within parameter matchers were compiled into publicly accessible client-side JavaScript bundles without triggering a build error.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 2 hours ago•CVE-2026-128071
6.5

CVE-2026-128071: Route-Rule Authorization Bypass via Encoded Slashes in Nuxt

CVE-2026-128071 is a route-rule authorization bypass and security policy circumvention vulnerability in the Nuxt web framework, affecting `nuxt`, `@nuxt/nitro-server`, and `@nuxt/vite-server` prior to version 4.6.4. Serving as an incomplete fix for GHSA-6gq8-jgmh-3ffp, the flaw arises from an interpretation conflict between Nuxt's route-rule matching logic and Vue Router's catch-all route parameter decoding. When processing an incoming HTTP request containing percent-encoded forward slashes (`%2F` or `%2f`), the route-rule evaluation engine preserves the encoded sequence as a single path segment, failing to match prefix-based rules such as `/admin/**`. However, when the request is subsequently dispatched to a catch-all page route (`app/pages/[...slug].vue`) or a multi-segment parameter handler, the parameters are URL-decoded into literal slash delimiters. This discrepancy allows unauthenticated remote attackers to bypass route-level redirects, authentication middleware (`appMiddleware`), security headers, proxy configurations, and rendering constraints (`ssr: false`, `noScripts`), while the catch-all page resolves and renders the protected resource.

Amit Schendel
Amit Schendel
3 views•11 min read
•about 3 hours ago•CVE-2026-128134
7.8

CVE-2026-128134: Local Code Execution via Untrusted Search Path in NLTK dependencygraph

In Natural Language Toolkit (NLTK) versions prior to 3.10.4, the nltk.parse.dependencygraph.dot2img function resolves the Graphviz dot binary through the system PATH using find_binary('dot') and invokes it directly via subprocess.run() instead of routing execution through nltk.pathsec.spawn_trusted(). This omission bypasses file ownership validation, directory writability checks, and dynamic loader environment scrubbing. On multi-user POSIX systems where a victim's PATH contains a directory writable by a local low-privileged attacker, the attacker can plant a malicious dot binary that executes under the victim's privileges when dependency graphs are rendered.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 4 hours ago•CVE-2026-119790
6.3

CVE-2026-119790: Cross-Request Cache Poisoning and Information Disclosure via Race Condition in Next.js

A race condition in Next.js versions 16.3.0 through 16.4.4 allows cross-request cache poisoning and unauthorized information disclosure across root parameters. When an application invokes the same `'use cache'` function both directly during rendering and wrapped inside `unstable_cache()`, a concurrent `unstable_cache()` request arriving during a cold start cache fill joins the in-flight execution. Because the `unstable_cache()` execution context lacks root parameter tracking, the parameter mismatch verification fails, causing `unstable_cache()` to persist root-parameter-scoped data under a global cache key.

Alon Barad
Alon Barad
5 views•9 min read
•about 5 hours ago•CVE-2026-128074
6.9

CVE-2026-128074: Regular Expression Denial of Service in Nuxt SSR Payload URL Generation

CVE-2026-128074 is an algorithmic complexity and Regular Expression Denial of Service (ReDoS) vulnerability in Nuxt versions 4.6.0 through 4.6.3. The flaw resides in the server-side rendering (SSR) runtime components responsible for payload URL generation and experimental early 404 route evaluation. By sending unauthenticated HTTP requests containing long sequences of repeated forward slashes followed by a non-slash character, an attacker can force the V8 regular expression engine into quadratic O(N^2) backtracking, blocking the single-threaded Node.js event loop and degrading application availability.

Alon Barad
Alon Barad
4 views•11 min read