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

CVE-2026-56669: Remote Denial of Service via Algorithmic Complexity and Interpretation Conflict in Elysia

Amit Schendel
Amit Schendel
Senior Security Researcher

Sep 23, 2026·6 min read·18 visits

Executive Summary (TL;DR)

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.

Vulnerability Overview

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.

Root Cause Analysis

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.

Code-Level Analysis

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 Methodology

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.

Impact Assessment

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.

Remediation & Mitigation

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.29

If 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.

Official Patches

ElysiaJSFix quadratic form parsing using Map grouping

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

ElysiaJS web applications running on Bun or Node.js runtimes using versions prior to 1.4.29

Affected Versions Detail

Product
Affected Versions
Fixed Version
elysia
ElysiaJS
< 1.4.291.4.29
AttributeDetail
CWE IDCWE-407, CWE-436
Attack VectorNetwork (AV:N)
CVSS Score7.5 (High)
EPSS Score0.0063 (Percentile: 48.83%)
ImpactDenial of Service (DoS)
Exploit StatusProof of Concept (PoC) Public
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1499Endpoint Denial of Service
Impact
T1499.004Endpoint Denial of Service: Application Exhaustion Flood
Impact
T1190Exploit Public-Facing Application
Initial Access
CWE-407
Inefficient Algorithmic Complexity

The product of an algorithm has an inefficient complexity calculation, exposing the system to denial of service.

References & Sources

  • [1]Elysia Security Advisory GHSA-9643-4qgh-g8mx
  • [2]Official Fix Commit
  • [3]Elysia Release v1.4.29
  • [4]Original Exploit PoC Gist
  • [5]PoC Gist Raw Text

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

•43 minutes ago•GHSA-QX75-2P3R-PWM5
7.7

CVE-2026-55622: Cross-Project Instance Copy Authorization Bypass in Canonical LXD and LXC Incus

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.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 2 hours ago•GHSA-7MR3-28H5-M5VX
7.7

GHSA-7mr3-28h5-m5vx: Authorization Bypass and Cross-Project Volume Copy in Canonical LXD

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.

Alon Barad
Alon Barad
3 views•10 min read
•about 3 hours ago•GHSA-47W9-6R3F-938G
9.9

GHSA-47w9-6r3f-938g: Authorization Bypass and Host Root Command Execution in Canonical LXD and Incus

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.

Alon Barad
Alon Barad
4 views•11 min read
•about 4 hours ago•GHSA-JPF8-86F3-WP38
9.9

CVE-2026-48752: Arbitrary Host File Read and Write via Templates Symlink in Canonical LXD and Incus

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.

Amit Schendel
Amit Schendel
4 views•10 min read
•1 day ago•CVE-2026-12411
8.4

CVE-2026-12411: Cross-Guest Volume Hijack via DevLXD Device PATCH in Canonical LXD

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.

Amit Schendel
Amit Schendel
7 views•10 min read
•1 day ago•CVE-2026-105769
9.3

CVE-2026-105769: Azure Entra ID Token Exfiltration in Kaniko via Unanchored ACR Hostname Regex

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.

Amit Schendel
Amit Schendel
11 views•11 min read