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

CVE-2026-27971: Unauthenticated Remote Code Execution in Qwik Framework RPC

Amit Schendel
Amit Schendel
Senior Security Researcher

Mar 13, 2026·6 min read·128 visits

Executive Summary (TL;DR)

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

Vulnerability Overview

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.

Root Cause Analysis

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.

Code Analysis

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 Mechanics

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.

Impact Assessment

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.

Remediation & Hardening

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.

Official Patches

QwikDevQwik Version 1.19.1 Release Notes

Technical Appendix

CVSS Score
9.8/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
EPSS Probability
13.43%
Top 99% most exploited

Affected Systems

Qwik Web FrameworkNode.js server environments running Qwik applications

Affected Versions Detail

Product
Affected Versions
Fixed Version
Qwik
QwikDev
<= 1.19.01.19.1
AttributeDetail
CWE IDCWE-502
CVSS v3.1 Score9.8 Critical
Attack VectorNetwork
Exploit StatusProof-of-Concept Available
EPSS Score0.13434 (94.07th Percentile)
CISA KEVNot Listed

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1059Command and Scripting Interpreter
Execution
CWE-502
Deserialization of Untrusted Data

Deserialization of Untrusted Data

Known Exploits & Detection

sebsrt.xyzFull Proof-of-Concept writeup and payload breakdown
NucleiDetection Template Available

Vulnerability Timeline

Vulnerability disclosed, CVE assigned, and Qwik version 1.19.1 released with the fix.
2026-03-03
Technical writeups and SentinelOne analysis published.
2026-03-06
Full Proof-of-Concept writeup released by researcher Sebastiano Sartor.
2026-03-09

References & Sources

  • [1]GitHub Security Advisory: GHSA-p9x5-jp3h-96mm
  • [2]Qwik Release v1.19.1
  • [3]Technical Writeup by Sebastiano Sartor
  • [4]SentinelOne Vulnerability Database: CVE-2026-27971
  • [5]Nuclei Detection Template

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

•2 days ago•CVE-2026-16454
4.3

CVE-2026-16454: Object-Level Authorization Bypass in Eclipse hawkBit Direct Device Integration Controller

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.

Amit Schendel
Amit Schendel
10 views•9 min read
•2 days ago•CVE-2026-62284
8.6

CVE-2026-62284: Remote Code Execution and SSRF via Unsanitized Kubeconfig in OSAC Operator

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.

Amit Schendel
Amit Schendel
8 views•8 min read
•2 days ago•CVE-2026-62361
5.5

CVE-2026-62361: Authenticated SQL Injection and Table Access Control Bypass in Listmonk Subscriber Export

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

Alon Barad
Alon Barad
9 views•11 min read
•2 days ago•CVE-2026-28385
5.0

CVE-2026-28385: Server-Side Request Forgery in Canonical LXD Image Import

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.

Amit Schendel
Amit Schendel
10 views•9 min read
•2 days ago•GHSA-9J25-MM2H-2F76
9.9

CVE-2026-48750: Arbitrary File Write on Host via exec-output Symlink in Canonical LXD and Incus

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

Alon Barad
Alon Barad
8 views•12 min read
•2 days ago•GHSA-VGHH-5RFX-XHQ8
9.9

CVE-2026-48749: Arbitrary Host File Read and Write via Malicious Image Symlink in Canonical LXD and Incus

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.

Amit Schendel
Amit Schendel
8 views•9 min read