Sep 23, 2026·6 min read·18 visits
A high-severity denial-of-service vulnerability in Elysia prior to v1.4.29 allows remote, unauthenticated attackers to freeze the server's single-threaded event loop. By using an interpretation conflict to bypass request-size filters, attackers can submit thousands of unique keys that trigger quadratic processing times during form-data normalization.
CVE-2026-56669 is a high-severity vulnerability in the Elysia web framework (ElysiaJS) that combines Inefficient Algorithmic Complexity (CWE-407) and an Interpretation Conflict (CWE-436). It allows remote, unauthenticated attackers to cause a complete Denial of Service (DoS) via CPU resource exhaustion using specially crafted multipart or urlencoded payloads.
Elysia is an ergonomic web framework designed primarily for the Bun runtime environment. When parsing incoming HTTP POST requests with structured payloads, Elysia normalizes form keys to resolve nested objects and array representations. This normalization mechanism is accessible to unauthenticated remote users on any endpoint that parses form data.
This vulnerability, tracked as CVE-2026-56669, involves a combination of algorithmic complexity mismatch and an HTTP header interpretation conflict. These weaknesses allow a remote attacker to force the server's process into a long-running CPU loop, blocking the runtime's single-threaded event loop and causing a complete denial of service.
The underlying cause is an algorithmic mismatch where the server-side runtime implements key validation in linear time while the framework iterates over keys sequentially. This combination yields quadratic execution time relative to the number of submitted parameters. An attacker can exploit this behavior with minimal network resources.
The root cause of this vulnerability lies in the combination of two security weaknesses. The first is Inefficient Algorithmic Complexity (CWE-407) in the form-data normalization process. The second is an Interpretation Conflict (CWE-436) in the handling of the HTTP Content-Type header.
During body parsing, Elysia iterates over keys returned by the form.keys() method. Within this iteration, the code invokes form.getAll(key) to extract the associated values. Standard JavaScript runtimes, including Bun and Node.js, implement standard FormData lookups as a linear scan over an internal sequential array, resulting in an O(N) complexity for each individual lookup.
Because the normalization loop executes N times and calls an O(N) function during each iteration, the total execution cost scales quadratically to O(N^2). A request containing 500,000 unique keys will require approximately 250 billion operations, blocking the main thread indefinitely.
To exploit this efficiently, an attacker uses an interpretation conflict. By setting the Content-Type header to multipart/form-data;(, application/x-www-form-urlencoded, Elysia recognizes the multipart/form-data substring and routes the request to its form-data parser. However, the underlying runtime's native parser rejects the malformed token and falls back to URL-encoded parsing, allowing the attacker to bundle half a million parameters into a compact body under 2 megabytes.
The vulnerability is located in the key normalization loops within src/dynamic-handle.ts and src/adapter/web-standard/index.ts. Below is a comparison of the vulnerable and patched code patterns.
// Vulnerable: Nested loop logic executing O(N^2) operations
body = {}
const form = await request.formData()
for (const key of form.keys()) {
if (body[key]) continue
// form.getAll(key) performs an O(N) linear scan over the internal array
const value = form.getAll(key)
const finalValue = normalizeFormValue(value)
if (key.includes('.') || key.includes('['))
// ... nested object handling ...
}The fix modifies the normalization iteration logic by replacing the multiple $O(N)$ linear scans with a single-pass grouping operation.
// Patched: Linear O(N) grouping logic using Map
body = {}
const form = await request.formData()
const grouped = new Map<string, any[]>()
// Iterate exactly once over the form elements: O(N) complexity
form.forEach((v, k) => {
const list = grouped.get(k)
if (list) list.push(v)
else grouped.set(k, [v])
})
// Iterate over unique Map entries in linear time
for (const [key, value] of grouped) {
if (body[key]) continue
const finalValue = normalizeFormValue(value)
if (key.includes('.') || key.includes('['))
// ... nested object handling ...
}The patched version replaces the nested iteration with a single pass grouping phase using an ES6 Map. Key lookups and insertions within the Map occur in constant $O(1)$ time, reducing the total computation complexity to linear $O(N)$ and preventing CPU starvation.
Exploitation of this vulnerability requires only a single, well-crafted HTTP POST request containing a large volume of unique query keys. The exploit can be initiated with standard command-line tools.
The attacker crafts an HTTP request body containing 500,000 distinct URL-encoded key-value pairs separated by ampersands. The attacker then assigns a malformed Content-Type header: multipart/form-data;(, application/x-www-form-urlencoded. This ensures the request bypasses standard multipart boundary size checks while still invoking the vulnerable form-data normalization logic.
Once the Elysia server receives the request, the native parser populates the FormData interface in linear time. The framework then initiates its key normalization loop, which attempts to run 250 billion operations on the single thread. This locks the CPU core at 100% capacity and stalls all subsequent HTTP connections until the process is restarted.
The primary impact of CVE-2026-56669 is complete denial of service. Because the Bun and Node.js runtimes run on a single-threaded event loop, blocking the main thread prevents the server from processing any other incoming connections.
No administrative privileges or special configurations are required to execute this attack. Any public endpoint that accepts incoming form submissions can be used as an entry point for exploitation.
This vulnerability does not lead to remote code execution, unauthorized data modification, or information disclosure. The impact is limited entirely to service availability, with a CVSS v3.1 base score of 7.5.
The recommended resolution is to upgrade the elysia dependency to version 1.4.29 or higher. This version updates the normalization logic to use the linear-time Map grouping mechanism.
# Upgrade Elysia using Bun package manager
bun add elysia@1.4.29If patching is not immediately feasible, deploy a Web Application Firewall rule or reverse proxy rule to filter malformed Content-Type headers. Reject any request where the Content-Type header contains commas, parentheses, or multiple media type declarations.
Additionally, configure rate-limiting rules and enforce limits on the maximum allowed form keys or request body sizes. Restricting the maximum number of unique form parameters to a reasonable threshold (e.g., 1000 fields) prevents attackers from achieving the payload density required to exhaust CPU resources.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
elysia ElysiaJS | < 1.4.29 | 1.4.29 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-407, CWE-436 |
| Attack Vector | Network (AV:N) |
| CVSS Score | 7.5 (High) |
| EPSS Score | 0.0063 (Percentile: 48.83%) |
| Impact | Denial of Service (DoS) |
| Exploit Status | Proof of Concept (PoC) Public |
| KEV Status | Not Listed |
The product of an algorithm has an inefficient complexity calculation, exposing the system to denial of service.
CVE-2026-55622 (GHSA-qx75-2p3r-pwm5) is an improper access control vulnerability (CWE-284) in Canonical LXD and LXC Incus (tracked as GHSA-c9f5-j9c3-mhrg). In multi-tenant deployments utilizing project-based isolation, the REST API handler for instance creation via POST /1.0/instances verifies that the authenticated user has authorization in the destination project specified by the query parameter, but fails to verify whether the user holds read or view permissions for the source instance when executing a copy operation across projects. Consequently, an authenticated client restricted to a single project can clone instances or snapshots from unauthorized projects into their own project, resulting in complete disclosure of the target instance filesystem and embedded credentials.
An authorization bypass vulnerability in Canonical LXD (tracked as GHSA-7mr3-28h5-m5vx and CVE-2026-55621, and as GHSA-64f3-v33m-w89f in Linux Containers Incus) allows an authenticated user with restricted project access to copy custom storage volumes and volume snapshots from unauthorized projects. The flaw resides in the storagePoolVolumesPost REST API handler, which verifies permissions on the destination project but fails to check whether the caller holds view entitlements on the source project or volume specified in the request body.
A missing authorization and configuration validation vulnerability in Canonical LXD and LXC Incus allows authenticated users within restricted projects to bypass project security boundaries. By smuggling prohibited low-level configuration directives (such as raw.lxc or raw.qemu) inside instance snapshots or backup archives, an attacker can restore these configurations within a restricted project and execute arbitrary commands with root privileges on the underlying host operating system.
A symbolic link traversal vulnerability (CWE-59) in Canonical LXD and Linux Containers Incus allows an authenticated user with image import permissions to read and write arbitrary files on the host filesystem. During image archive unpacking, the daemon fails to reject top-level symbolic links for the instance `templates` directory. Subsequent requests to the instance template API endpoints follow this symbolic link outside the instance storage directory with root privileges, enabling complete host compromise.
CVE-2026-12411 is a broken access control vulnerability in the DevLXD interface of Canonical LXD versions 6.6 through 6.8. The flaw resides in the devLXDInstancePatchHandler component, which fails to verify storage volume ownership when an instance attaches a new disk device via the /dev/lxd guest socket. When the security.devlxd.management.volumes configuration option is enabled, an untrusted guest or DevLXD identity can issue a crafted HTTP PATCH request referencing another tenant's custom storage volume. The LXD host daemon subsequently mounts the target volume into the requesting guest, permitting unauthorized cross-tenant read and write operations.
CVE-2026-105769 (GHSA-5q7h-w9jf-cx97, GO-2026-6225) is an origin validation error and credential exfiltration vulnerability affecting Kaniko prior to version 1.25.20. The flaw stems from an unanchored regular expression in the integrated Azure Container Registry (ACR) credential helper (github.com/chrismellard/docker-credential-acr-env). When Kaniko processes a Dockerfile containing an image reference hosted on a lookalike domain containing an ACR suffix as a substring (e.g., x.azurecr.io.attacker.com), the credential helper acquires a Microsoft Entra ID access token for Azure Resource Manager and transmits it via HTTP POST to the attacker-controlled host.