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

CVE-2026-62336: Local Privilege Escalation via Symlink Following in qbee-agent

Amit Schendel
Amit Schendel
Senior Security Researcher

Nov 18, 2026·10 min read·1 visit

Executive Summary (TL;DR)

An improper link resolution flaw (CWE-59) in qbee-agent prior to version 2026.27 allows local unprivileged attackers to escalate privileges to root or corrupt system files by planting symbolic links in managed directories (such as ~/.ssh) or predictable temporary staging paths (/tmp/.bundle.raucb.part).

CVE-2026-62336 (GHSA-xhv5-8fpq-g7hf) is a high-severity local privilege escalation, arbitrary file overwrite, and denial-of-service vulnerability in qbee-agent, the client daemon for the qbee.io IoT device management platform. Prior to version 2026.27, the root-privileged agent failed to validate path components against symbolic links during directory creation and file opening operations in app/configuration/file_manager.go. Local unprivileged users can exploit this flaw by planting symlinks in user-controlled configuration paths or predictable temporary staging locations, causing the daemon to overwrite, truncate, or change ownership of sensitive root-owned system files.

Vulnerability Overview

qbee-agent is the open-source endpoint management daemon for the qbee.io IoT platform. In standard deployments, the agent executes continuously as the root user to synchronize system configurations, manage local user SSH keys, distribute arbitrary files, and apply over-the-air (OTA) firmware updates via RAUC bundles.

Because the agent operates at the highest privilege level while interacting with directories owned by unprivileged users and world-writable temporary file systems, it exposes a critical local attack surface. Specifically, when the agent materializes configuration artifacts on disk, it must cross privilege boundaries between root and unprivileged local accounts.

Prior to version 2026.27, the internal file management implementation in app/configuration/file_manager.go did not restrict symbolic link resolution during ancestor directory traversal or terminal file opening. This vulnerability is classified under CWE-59 (Improper Link Resolution Before File Access), alongside secondary classifications including CWE-22 (Path Traversal), CWE-367 (TOCTOU Race Condition), CWE-377 (Insecure Temporary File), and CWE-282 (Improper Ownership Management).

A local attacker with a standard unprivileged account can place symbolic links in paths processed by the agent, such as ~/.ssh/authorized_keys or /tmp/.bundle.raucb.part. When the agent executes its synchronization routine, it follows the attacker-controlled symlink and writes to, truncates, or changes the ownership (chown) of the target file with root privileges.

Root Cause Analysis

The root cause of CVE-2026-62336 resides in two helper functions within app/configuration/file_manager.go: createFile() and makeDirectories(). Both functions perform filesystem operations as root without verifying whether the target path or its parent directories are symbolic links.

First, createFile() opens target files using os.OpenFile with the os.O_RDWR and os.O_CREATE flags, optionally appending os.O_TRUNC. Because the flags omit syscall.O_NOFOLLOW, the operating system kernel automatically dereferences any symbolic link present at the terminal path component. If an attacker pre-creates a symlink at a predictable path, os.OpenFile opens or truncates the link target rather than failing.

Second, before opening the terminal file, createFile() invokes makeDirectories() to ensure all parent directories exist. In vulnerable versions, makeDirectories() inspected parent paths using os.Stat(dirPath). Because os.Stat follows symbolic links, any symlinked intermediate directory pointing to an existing directory (such as /root/.ssh) was evaluated as a valid directory. Furthermore, makeDirectories() only walked up the directory tree if os.Stat returned os.ErrNotExist, meaning existing symlinked ancestor directories were never inspected or rejected.

Finally, after creating or opening the file, the agent executes ownership adjustments (Chown) using the uid and gid specified in fileCreateData. When combined with unrestricted link following, this allows an attacker to redirect ownership changes onto arbitrary system files.

Code Analysis

The vulnerability was remediated in commit 0fdf8e411de5d0c142ae2590cf1c54bdfc2e529a (Pull Request #131). The patch modifies app/configuration/file_manager.go to enforce strict non-dereferencing checks across both intermediate directory components and the final file target.

diff --git a/app/configuration/file_manager.go b/app/configuration/file_manager.go
index acf2b210..d3fca838 100644
--- a/app/configuration/file_manager.go
+++ b/app/configuration/file_manager.go
@@ -491,13 +491,18 @@ func calculateTemplateDigest(src string, params map[string]string) (string, erro
 }
 
 // createFile under provided path and with provided uid and gid.
+//
+// The agent typically runs as root, so all path resolution here must refuse
+// to follow attacker-controlled symlinks (CWE-59). makeDirectories rejects
+// symlinked intermediate components; O_NOFOLLOW rejects a symlinked final
+// component so we never open, truncate, or chown an attacker-chosen target.
 func createFile(path string, fileCreateData *fileCreateData, permission os.FileMode, truncate bool) (*os.File, error) {
 	var err error
 	if err = makeDirectories(path, fileManagerDefaultDirectoryPermission, fileCreateData.uid, fileCreateData.gid); err != nil {
 		return nil, err
 	}
 
-	openFlags := os.O_RDWR | os.O_CREATE
+	openFlags := os.O_RDWR | os.O_CREATE | syscall.O_NOFOLLOW
 
 	if truncate {
 		openFlags = openFlags | os.O_TRUNC
@@ -608,6 +613,10 @@ func determineFileCreateData(dst string) (*fileCreateData, error) {
 }
 
 // makeDirectories checks if all directories for the dst file exist, if not, create them with provided owner and group.
+//
+// All ancestor components are inspected with os.Lstat so that a symlinked
+// directory (e.g. an attacker's ~/.ssh pointing at /root/.ssh) is rejected
+// rather than transparently traversed by the kernel (CWE-59).
 func makeDirectories(dst string, permissions os.FileMode, uid, gid int) error {
 	if dst == "/" {
 		return nil
@@ -615,13 +624,14 @@ func makeDirectories(dst string, permissions os.FileMode, uid, gid int) error {
 
 	dirPath := filepath.Dir(dst)
 
-	dirInfo, err := os.Stat(dirPath)
-	if errors.Is(err, os.ErrNotExist) {
-		// ensure parent exists
-		if err = makeDirectories(dirPath, permissions, uid, gid); err != nil {
-			return err
-		}
+	// Always validate / materialize ancestors first so that symlinks higher
+	// up the path are caught even when dirPath itself already exists.
+	if err := makeDirectories(dirPath, permissions, uid, gid); err != nil {
+		return err
+	}
 
+	dirInfo, err := os.Lstat(dirPath)
+	if errors.Is(err, os.ErrNotExist) {
 		if err = os.Mkdir(dirPath, permissions); err != nil {
 			return fmt.Errorf("cannot create directorty %s: %w", dirPath, err)
 		}
@@ -637,6 +647,10 @@ func makeDirectories(dst string, permissions os.FileMode, uid, gid int) error {
 		return fmt.Errorf("cannot create directory %s: %w", dirPath, err)
 	}
 
+	if dirInfo.Mode()&os.ModeSymlink != 0 {
+		return fmt.Errorf("refusing to traverse symlinked path component %s", dirPath)
+	}
+
 	if !dirInfo.IsDir() {
 		return fmt.Errorf("cannot create directory, %s is a file", dirPath)
 	}

The patch addresses the flaw through three changes:

  1. Terminal Link Rejection: createFile() adds syscall.O_NOFOLLOW to openFlags. If the final path component is a symbolic link, os.OpenFile fails immediately with ELOOP (too many levels of symbolic links).
  2. Top-Down Ancestor Validation: makeDirectories() unconditionally recurses to the root directory (/) before inspecting dirPath. This guarantees that every ancestor component in the hierarchy is validated, even if the leaf directory already exists.
  3. Non-Dereferencing Stat: os.Stat(dirPath) is replaced with os.Lstat(dirPath), followed by an explicit bitmask check (dirInfo.Mode()&os.ModeSymlink != 0). If any intermediate component is a symbolic link, the function aborts before reaching os.OpenFile.

> [!NOTE] > Fix Completeness Assessment: While replacing os.Stat with os.Lstat in makeDirectories() prevents static symlink attacks, performing sequential user-space Lstat checks followed by os.OpenFile on a full path string remains theoretically susceptible to Time-of-Check Time-of-Use (TOCTOU / CWE-367) race conditions if an attacker can rapidly swap an intermediate directory with a symlink between the Lstat check and the OpenFile call. Complete immunity against directory-level TOCTOU races on Linux requires directory file descriptor pinning (openat with O_NOFOLLOW | O_DIRECTORY or Linux openat2 with RESOLVE_NO_SYMLINKS). However, the patch effectively mitigates deterministic exploitation across standard configuration and staging workflows.

Exploitation

Exploitation requires local unprivileged execution on a host running qbee-agent < 2026.27 as root. No user interaction is needed; the exploit triggers automatically during the agent's periodic configuration evaluation loop. Three primary exploitation vectors exist depending on the active agent bundles.

Vector 1: Root SSH Key Injection via Intermediate Directory Symlink

When the SSH Keys Bundle is active for an unprivileged user (e.g., alice), qbee-agent writes managed public keys to /home/alice/.ssh/authorized_keys. Because alice owns /home/alice, the user can replace the .ssh directory with a symlink to /root/.ssh. Note that Linux kernel fs.protected_symlinks only restricts symlinks inside sticky world-writable directories (like /tmp) and does not prevent root from following a symlink inside /home/alice.

rm -rf /home/alice/.ssh
ln -s /root/.ssh /home/alice/.ssh

Upon the next synchronization cycle, qbee-agent traverses /home/alice/.ssh into /root/.ssh and writes alice's authorized keys directly into /root/.ssh/authorized_keys, granting immediate root SSH access.

Vector 2: Arbitrary System File Overwrite via RAUC Staging

When the RAUC Update Bundle downloads OTA firmware packages, it stages partial downloads at the static, predictable path /tmp/.bundle.raucb.part. On systems where fs.protected_symlinks is disabled or absent (such as minimal embedded Linux kernels), a local user can pre-create a symlink at this path targeting /etc/shadow or /etc/sudoers:

ln -s /etc/shadow /tmp/.bundle.raucb.part

When qbee-agent initiates a bundle download, it calls createFile() with truncate = true, immediately truncating and overwriting /etc/shadow with binary RAUC bundle data.

Proof of Concept (Unit Test Reproducer)

Commit 0fdf8e411de5d0c142ae2590cf1c54bdfc2e529a includes a Go unit test in app/configuration/file_manager_test.go that reproduces both attack vectors:

func Test_createFile_doesNotFollowSymlinks(t *testing.T) {
	t.Run("symlinked intermediate directory (authorized_keys variant)", func(t *testing.T) {
		tempDir := t.TempDir()
		victimDir := filepath.Join(tempDir, "root_ssh")
		_ = os.Mkdir(victimDir, 0700)
		victimFile := filepath.Join(victimDir, "authorized_keys")
		_ = os.WriteFile(victimFile, []byte("root-original-authorized-keys\n"), 0600)
 
		attackerHome := filepath.Join(tempDir, "alice_home")
		_ = os.Mkdir(attackerHome, 0700)
 
		// Attacker plants ~alice/.ssh -> /root/.ssh
		sshSymlink := filepath.Join(attackerHome, ".ssh")
		_ = os.Symlink(victimDir, sshSymlink)
 
		targetPath := filepath.Join(sshSymlink, "authorized_keys")
		fcd := &fileCreateData{uid: os.Geteuid(), gid: os.Getegid(), bytesAvail: 1 << 30}
 
		file, err := createFile(targetPath, fcd, sshAuthorizedKeysFilePermission, true)
		if file != nil {
			_, _ = file.Write([]byte("attacker-supplied-key\n"))
			_ = file.Close()
		}
	})
}

Impact Assessment

Successful exploitation of CVE-2026-62336 results in complete compromise of the local operating system, granting an unprivileged local user full root privileges or the ability to render the device inoperable.

Under CVSS v4.0, the vulnerability carries a base score of 8.5 (High) with the vector CVSS:4.0/AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N:

  • Confidentiality Impact (VC:H): By hijacking file ownership (chown) via the File Distribution bundle or injecting SSH keys into /root/.ssh/authorized_keys, an attacker gains read access to all restricted system files, cryptographic keys, and device secrets.
  • Integrity Impact (VI:H): Attackers can overwrite arbitrary root-owned files or elevate privileges to modify system binaries and configurations.
  • Availability Impact (VA:H): Truncating critical authentication or boot files (such as /etc/shadow or /etc/passwd) via the /tmp/.bundle.raucb.part staging symlink locks out administrators and causes an endpoint denial of service.

The Exploit Prediction Scoring System (EPSS) assigns CVE-2026-62336 a score of 0.00100 (0.10%), placing it in the 0.84th percentile. While remote exploitation is not possible directly, this vulnerability poses a severe risk to multi-user IoT gateways, shared edge compute nodes, or containerized workloads that share host directory mounts managed by qbee-agent.

Remediation & Defensive Guidance

Organizations running qbee-agent must upgrade to version 2026.27 or later. Version 2026.27 enforces syscall.O_NOFOLLOW on file creation and inspects all ancestor directory components via os.Lstat to reject symbolic links.

If immediate patching is not feasible on deployed IoT devices, administrators should apply the following compensating controls:

  1. Enforce Kernel Symlink Protections: Ensure the Linux kernel fs.protected_symlinks parameter is enabled (1) to block symlink following inside world-writable sticky directories like /tmp. Note that this mitigates the /tmp/.bundle.raucb.part vector but does not stop the ~/.ssh intermediate directory vector.
  2. Restrict File Distribution Paths: Avoid configuring qbee-agent File Distribution or SSH Keys bundles to write into directories owned by untrusted local users.
# /etc/sysctl.d/99-symlink-protection.conf
fs.protected_symlinks = 1
fs.protected_hardlinks = 1
fs.protected_fifos = 2
fs.protected_regular = 2

Security teams can detect exploitation attempts by monitoring qbee-agent logs for refusing to traverse symlinked path component or too many levels of symbolic links, and by configuring auditd to log symlink creation events targeting sensitive paths:

auditctl -a always,exit -F arch=b64 -S symlink,symlinkat -F success=1 -k symlink_creation
find /home -maxdepth 3 -type l -ls

Official Patches

qbee-ioGitHub Security Advisory GHSA-xhv5-8fpq-g7hf
qbee-ioOfficial Patch Commit in qbee-io/qbee-agent
qbee-ioqbee-agent Release 2026.27

Fix Analysis (1)

Technical Appendix

CVSS Score
8.5/ 10
CVSS:4.0/AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
EPSS Probability
0.10%
Top 99% most exploited

Affected Systems

qbee-io/qbee-agent

Affected Versions Detail

Product
Affected Versions
Fixed Version
qbee-agent
qbee-io
< 2026.272026.27
AttributeDetail
CVE IDCVE-2026-62336 (GHSA-xhv5-8fpq-g7hf)
WeaknessCWE-59 (Improper Link Resolution Before File Access)
Attack VectorLocal (Unprivileged User / Symlink Planting)
CVSS v4.08.5 High (CVSS:4.0/AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N)
EPSS Score0.10% (0.84th Percentile)
ImpactLocal Privilege Escalation to root, Arbitrary File Overwrite, Denial of Service
Exploit StatusProof-of-Concept Available (Unit Test Reproducer)
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1083File and Directory Discovery
Discovery
T1005Data from Local System
Collection
T1068Exploitation for Privilege Escalation
Privilege Escalation
T1078.001Valid Accounts: Default Accounts
Privilege Escalation
T1499Endpoint Denial of Service
Impact
CWE-59
Improper Link Resolution Before File Access ('Link Following')

The software attempts to access a file based on the filename, but it does not properly prevent that filename from identifying a link or shortcut that resolves to an unintended resource.

Known Exploits & Detection

GitHubOfficial patch commit containing Go unit test reproducers (Test_createFile_doesNotFollowSymlinks) demonstrating both the ~/.ssh intermediate symlink and /tmp/.bundle.raucb.part staging attacks.

Vulnerability Timeline

CVE-2026-62336 and GHSA-xhv5-8fpq-g7hf published; qbee-agent 2026.27 released with fix.
2026-11-16

References & Sources

  • [1]GitHub Security Advisory GHSA-xhv5-8fpq-g7hf
  • [2]Official Patch Commit (0fdf8e411de5d0c142ae2590cf1c54bdfc2e529a)
  • [3]Pull Request #131: Refuse to follow symlinks in file manager
  • [4]qbee-agent Release 2026.27
  • [5]CVE-2026-62336 Record on CVE.org
  • [6]National Vulnerability Database (NVD) - CVE-2026-62336

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

•about 1 hour ago•CVE-2026-110782
8.7

CVE-2026-110782: Cryptographic Signature Verification Bypass and Cross-IdP Impersonation in SimpleSAMLphp SAML2

CVE-2026-110782 is an authentication bypass and cryptographic signature verification failure in the SimpleSAMLphp SAML2 library (simplesamlphp/saml2). Resulting from an incomplete fix for CVE-2026-49283, the HTTP-Artifact binding implementation verifies the outer ArtifactResponse signature but unconditionally returns unsigned embedded SAML Responses without verifying signatures or validating that the embedded issuer matches the artifact issuer. In multi-IdP federation environments, an attacker controlling one trusted Identity Provider (IdP) can forge arbitrary identity assertions claiming to originate from another trusted IdP.

Amit Schendel
Amit Schendel
3 views•11 min read
•about 2 hours ago•CVE-2026-110789
7.5

CVE-2026-110789: Pre-Authentication Denial of Service via ASN.1 DER Length Parsing in js-libp2p (@libp2p/crypto)

CVE-2026-110789 (GHSA-rvfr-cqwq-rc4j) is a high-severity pre-authentication Denial of Service (DoS) vulnerability in the @libp2p/crypto package of the js-libp2p networking stack prior to version 5.1.22. An improper length validation flaw in the ASN.1 DER decoder allows an unauthenticated remote peer to send a crafted RSA public key during the Identify protocol exchange, forcing the parser into a synchronous loop over attacker-claimed length values. Because this loop executes within a single Node.js event-loop tick prior to identity or cryptographic signature verification, it bypasses application timeouts, stalls the event loop for 4 to 5 seconds per connection, and transiently allocates up to 2 GB of memory.

Amit Schendel
Amit Schendel
4 views•11 min read
•about 3 hours ago•CVE-2026-119793
7.5

CVE-2026-119793: Unbounded Topic Map Allocation Denial of Service in js-libp2p GossipSub

CVE-2026-119793 (GHSA-x2vm-cf3p-m2w8) is a resource consumption vulnerability in the @libp2p/gossipsub module of the js-libp2p ecosystem. Prior to @libp2p/gossipsub version 17.0.0 and js-libp2p version 3.3.9, the GossipSub implementation processed incoming subscription RPC messages without enforcing per-peer or global limits on the number or cumulative byte size of subscribed topics in its default configuration. An unauthenticated remote peer can exploit this flaw by streaming continuous batches of unique topic subscription strings over an established connection, causing unbounded growth of the internal topics Map. This leads to V8 heap exhaustion (Out-Of-Memory crash) and severe CPU starvation on the main event loop during peer disconnection teardown.

Amit Schendel
Amit Schendel
3 views•12 min read
•about 4 hours ago•CVE-2026-69241
5.4

CVE-2026-69241: Stored Cross-Site Scripting via Unsanitized SVG Upload in Filament Curator

Filament Curator, a media picker plugin for Filament panels in Laravel applications, contains a Stored Cross-Site Scripting (XSS) vulnerability in versions prior to 3.7.9, 4.1.2, and 5.1.2. The application accepts image/svg+xml uploads by default and stores them on disk without stripping executable XML markup. When a panel user opens an uploaded SVG via the View action, the file renders as a top-level document in the browser, executing embedded JavaScript within the origin of the Filament application.

Alon Barad
Alon Barad
4 views•9 min read
•about 7 hours ago•CVE-2026-63182
8.1

CVE-2026-63182: XML Signature Wrapping Authentication Bypass in LightSAML

CVE-2026-63182 is a high-severity XML Signature Wrapping (XSW) vulnerability in LightSAML (litesaml/lightsaml), a PHP library implementing SAML 2.0 data models and cryptographic verification. An architectural discrepancy between how LightSAML deserializes direct child assertions and how the underlying robrichards/xmlseclibs library resolves XML document fragment identifiers allows an attacker with a valid signed assertion to forge arbitrary SAML identity claims and bypass authentication.

Alon Barad
Alon Barad
4 views•11 min read
•about 8 hours ago•CVE-2026-119351
6.3

CVE-2026-119351: Cross-Context Cache Leak via Delayed Inner Stream Metadata in Next.js

A race condition and improper synchronization vulnerability (CWE-362) exists in Next.js versions 16.2.0 prior to 16.4.5 when Cache Components ('use cache' directive) are enabled. When an outer cached function calls a nested cached function that reads dynamic root parameters via 'next/root-params' and returns an object containing pending promises, React Flight can resolve and deliver the ready portion of the payload before the inner cache finishes publishing its root parameter dependencies. Consequently, the outer cache entry finalizes and persists under a cache key that omits the root parameter dependencies, causing the first written cache entry to be served across requests with different root parameter values and bypassing nested cache invalidation rules.

Amit Schendel
Amit Schendel
7 views•10 min read