Nov 18, 2026·10 min read·1 visit
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.
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.
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.
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:
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).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.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 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.
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/.sshUpon 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.
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.partWhen qbee-agent initiates a bundle download, it calls createFile() with truncate = true, immediately truncating and overwriting /etc/shadow with binary RAUC bundle data.
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()
}
})
}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:
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./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.
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:
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.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 = 2Security 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 -lsCVSS:4.0/AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N| Product | Affected Versions | Fixed Version |
|---|---|---|
qbee-agent qbee-io | < 2026.27 | 2026.27 |
| Attribute | Detail |
|---|---|
| CVE ID | CVE-2026-62336 (GHSA-xhv5-8fpq-g7hf) |
| Weakness | CWE-59 (Improper Link Resolution Before File Access) |
| Attack Vector | Local (Unprivileged User / Symlink Planting) |
| CVSS v4.0 | 8.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 Score | 0.10% (0.84th Percentile) |
| Impact | Local Privilege Escalation to root, Arbitrary File Overwrite, Denial of Service |
| Exploit Status | Proof-of-Concept Available (Unit Test Reproducer) |
| CISA KEV Status | Not Listed |
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.
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.
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.
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.
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.
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.
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.