/

CVE-2026-60102

Severity:

HIGH RISK

(8.8)

OS Command Injection (CWE-78) in Horde VFS SMB Driver

CVE-2026-60102

Deferred

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution

Severity:

HIGH RISK

(8.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Horde Virtual File System's SMB driver improperly escapes user-controlled filenames before passing them to a shell, enabling OS command injection.

Authenticated attackers who can perform file operations (upload, rename, delete, folder creation) may execute arbitrary commands on the underlying system when filenames are interpolated into /bin/sh -c via proc_open().

Affected context

This vulnerability arises in deployments using the Horde Virtual File System API with the Horde_Vfs_Smb backend prior to version 3.0.1.

It affects environments where:

  • The SMB VFS driver is configured to interact with remote shares via smbclient.
  • User-supplied filenames or directory names are passed through the _escapeShellCommand() helper.
  • The application invokes smbclient through /bin/sh -c using proc_open(), interpolating the sanitized argument into a double-quoted shell command line.

The risk is most pronounced when users have permissions to create, rename, or delete files and folders through the Horde interface.

Exploit preconditions

  • Attack surface: Horde VFS SMB endpoints and UI flows that accept filenames or directory names (e.g., upload, folder creation, rename, deletion).
  • Required access: Valid authenticated access with the ability to perform file operations in a context mapped to the Horde_Vfs_Smb driver.
  • Trigger point: Any code path where a user-controlled filename is passed to _escapeShellCommand(), embedded into a double-quoted shell string, and executed via proc_open("/bin/sh -c ...").
  • Why exploitation is possible: The escaping routine fails to neutralize command substitution syntax (such as $(...) and related constructs), allowing attacker-controlled segments to be interpreted by the shell as executable expressions prior to running smbclient.

Why this happens

The root cause is an incomplete output encoding and validation strategy for data sent to the operating system shell, mapping directly to CWE-78: Improper Neutralization of Special Elements used in an OS Command.

The Horde_Vfs_Smb driver relies on _escapeShellCommand() to sanitize user-controlled filenames before constructing a shell command string, but the function does not safely handle command substitution sequences in a double-quoted context.

As a result, even though some characters may be escaped, remaining metacharacters are still meaningful to /bin/sh, enabling injection of additional commands or expressions when the composed command line is executed through proc_open().

Potential impact

  • Arbitrary command execution with the privileges of the web server or PHP process hosting Horde.
  • Reading, modifying, or deleting local files accessible to the service account.
  • Lateral movement within the host environment or connected network, depending on accessible tools and credentials.
  • Exfiltration of sensitive configuration data, environment variables, and credentials.
  • Disruption of service availability, including process crashes or deliberate resource exhaustion.

General mitigation guidance

Effective mitigation focuses on eliminating direct shell interpretation of user-controlled values and enforcing strict separation between data and commands.

Recommended defensive patterns include:

  • Avoiding shell-based wrappers for smbclient by using safer APIs or direct library bindings where possible.
  • Constructing process invocations using parameter arrays (bypassing /bin/sh -c) so user input is never parsed by a shell.
  • Implementing rigorous validation and canonicalization of filenames and directory names, rejecting or normalizing input containing shell metacharacters or command substitution syntax.
  • Applying context-appropriate escaping routines that fully neutralize all shell-special characters when shell invocation is unavoidable.
  • Running the Horde application and SMB interaction components under least-privilege accounts with minimal filesystem and network permissions to limit the blast radius of potential exploitation.

How teams detect issues like this

Detection and prevention can be strengthened through a combination of code-centric and operational techniques:

  • Static analysis: Configure rules to flag any use of proc_open(), exec-like functions, or /bin/sh -c that interpolate user-controlled variables, especially within the Horde_Vfs_Smb or similar drivers.
  • Code review: During security-focused reviews, highlight patterns where filenames are concatenated into shell command strings and verify that either the shell is not involved or robust, context-aware escaping and validation are in place.
  • Security linters and policies: Integrate automated tools in CI that detect command construction with untrusted input and enforce policies such as "no shell invocation with user data."
  • Runtime monitoring: Use application and system-level logging to track unexpected command executions or anomalous smbclient invocations, correlating unusual argument patterns with application requests.

Sources

SourceLink
github.comgithub.com/horde/Vfs/commit/41f74b4acfc144e09013d04dd121e0a5da808361
github.comgithub.com/horde/Vfs/pull/10
github.comgithub.com/horde/Vfs/releases/tag/v3.0.1
vulncheck.comvulncheck.com/advisories/horde-vfs-os-command-injection-via-horde-vfs-smb-driver

Frequently asked

questions

Yes, in typical configurations an attacker can exploit it remotely via the web interface or API, provided they have authenticated access and can perform file operations that reach the Horde_Vfs_Smb driver.

Exploitation generally requires only the level of access needed to create, rename, or delete files or folders through Horde. The precise role required depends on how permissions are configured, but administrative privileges are not inherently necessary.

The most robust fix is to avoid passing user-controlled values to a shell altogether. Use direct process execution with argument arrays or a non-shell-based interface to SMB, combined with strict input validation for filenames and paths.

Establish a secure coding standard that prohibits shell invocation with untrusted input, adopt libraries that abstract away shell interaction, and integrate automated checks in CI to detect risky process execution patterns during development.

Find out what's already
exploitable in your codebase.