Jul 28, 2026·5 min read·39 visits
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.
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.
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.
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 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.
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.
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.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:N/I:N/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
QTINeon Quiet-Terminal-Interactive | == 1.0.0 | None |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-400 |
| Attack Vector | Network (AV:N) |
| CVSS Score | 8.6 |
| Scope | Changed (S:C) |
| Impact | Availability (A:H) |
| Exploit Status | none |
| KEV Status | Not Listed |
The product does not properly control the allocation and maintenance of a limited resource, enabling an actor to cause resource exhaustion.
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.
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.
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.
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.
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.
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.