Mar 13, 2026·6 min read·128 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
CVE-2026-16454 is an object-level authorization bypass vulnerability (CWE-284, CWE-862) in Eclipse hawkBit versions 1.0.3 and prior. The flaw exists within the Direct Device Integration (DDI) REST controller (hawkbit-ddi-resource), where endpoints responsible for enumerating software module metadata and serving firmware binaries fail to verify whether the requested software module is assigned to the authenticated device. Consequently, any device with valid credentials (such as a TargetToken or GatewayToken) can enumerate software module identifiers and download arbitrary firmware artifacts across the entire tenant namespace.
CVE-2026-62284 (GHSA-5w5g-j6hw-6p8f) is a code injection and server-side request forgery vulnerability in the console-proxy component of the OSAC Operator. The RemoteConfigResolver parses Kubernetes Secrets containing kubeconfig files via clientcmd.RESTConfigFromKubeConfig without sanitizing execution-related fields. An attacker with RBAC permissions to create or modify labeled Secrets in monitored namespaces can supply a malicious exec credential plugin, resulting in arbitrary command execution within the console-proxy pod.
CVE-2026-62361 (GHSA-xgjr-7j9q-2h4r) is an authenticated SQL injection and authorization bypass vulnerability in listmonk, an open-source, self-hosted newsletter and mailing list manager written in Go. In versions prior to 6.2.0, the subscriber export endpoint (GET /api/subscribers/export) directly interpolates user-supplied SQL filter expressions into a PostgreSQL query without invoking the table allowlist validation function (validateQueryTables). Consequently, authenticated users possessing the subscribers:sql_query and subscribers:get_all permissions can bypass relational access controls, execute arbitrary subqueries against restricted tables such as users and settings, and modify database state via writable Common Table Expressions (CTEs).
CVE-2026-28385 (GHSA-3gq2-x4qg-p4g6) is a Server-Side Request Forgery (SSRF) vulnerability in Canonical LXD versions 4.12 through 6.9. An authenticated user possessing the can_create_images entitlement can force the LXD daemon to execute arbitrary outbound HTTP and HTTPS requests via the /1.0/images API endpoint. Due to the absence of egress destination validation, an attacker can probe host loopback services, RFC 1918 private network segments, and cloud Instance Metadata Services (IMDS) from the network position of the privileged LXD daemon.
Canonical LXD and LXC Incus contain an arbitrary file write vulnerability (CWE-73 / CWE-59) in the `/1.0/instances/<name>/exec` REST API endpoint. When an instance is unpacked from an image archive, top-level symbolic links are extracted directly onto the host filesystem within the instance storage directory. If a crafted image includes a symbolic link named `exec-output` pointing to an arbitrary host path, invoking the execution endpoint with `record-output: true` causes the privileged host daemon to follow the symlink and write command output files directly to the target host directory. An authenticated attacker with permissions to import images and execute commands can exploit this flaw to write controlled content to sensitive host directories such as `/etc/cron.d`, resulting in arbitrary code execution on the host as `root`.
CVE-2026-48749 (tracked as GHSA-vghh-5rfx-xhq8 for LXD and GHSA-2q3f-q5pq-g8wv for Incus) is a critical container escape vulnerability in the Canonical LXD and Linux Containers Incus system container managers. By importing a specially crafted container image archive containing duplicate tar member headers, an authenticated attacker can replace the instance rootfs directory with a symbolic link pointing to the underlying host root filesystem. When performing file operations on a stopped container, the privileged forkfile helper binary resolves the symbolic link without confinement and chroots directly into the host filesystem, granting arbitrary root-level file read and write access.