/

CVE-2026-30461

Severity:

HIGH RISK

(8.3)

Command Injection in FuelCMS Installer add_git_submodule

CVE-2026-30461

Modified

Vulnerability type

Category:

Command Injection

CWE:

CWE-77

Impact:

Authenticated Remote Code Execution

Severity:

HIGH RISK

(8.3)

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

Daylight Studio FuelCMS v1.5.2 contains an authenticated remote code execution vulnerability in the installer controller's add_git_submodule function.

By abusing command construction in /controllers/Installer.php, an authenticated attacker can inject arbitrary shell commands and execute them on the hosting server.

Affected context

This vulnerability exists in FuelCMS v1.5.2 within the installer component, specifically the add_git_submodule functionality in Installer.php.

It affects deployments where:

  • The FuelCMS application is reachable over a network
  • The installer controller and its functions remain accessible to authenticated users
  • The application invokes underlying shell commands (e.g., Git) using user-influenced input without strict sanitization

Exploit preconditions

  • Attack surface: Web interface of the FuelCMS application, targeting the installer controller
  • Required access: Valid authenticated account with permission to reach the installer/add_git_submodule functionality
  • Trigger point: Submission of crafted input parameters that are incorporated into shell command strings in Installer.php
  • Why exploitation is possible: User-controlled data is concatenated into shell command lines without robust validation, escaping, or strict argument handling, allowing shell metacharacters to alter command execution flow

Why this happens

The root cause is unsafe command construction within the installer logic, where the add_git_submodule function builds shell commands (likely Git submodule operations) by concatenating user-provided values directly into a command string and passing it to the shell.

This behavior maps to CWE-77: Improper Neutralization of Special Elements used in a Command ('Command Injection'), where untrusted input containing special shell characters (such as ;, &&, |) is not neutralized before being executed.

At a design level, the code implicitly trusts authenticated user input and treats it as benign command arguments, instead of applying strict validation and using parameterized process execution APIs that avoid invoking a shell.

Potential impact

  • Remote execution of arbitrary commands with the web server's operating system privileges
  • Reading, modifying, or deleting application and system files accessible to the web process
  • Installation of web shells or backdoors for persistent access
  • Lateral movement to other internal systems reachable from the compromised server
  • Exfiltration of configuration data, including database credentials and API keys
  • Complete compromise of the CMS instance and underlying host in certain configurations

General mitigation guidance

Effective mitigation focuses on eliminating direct shell command construction pathways and reducing trust in user-supplied input:

  • Replace shell-based command execution with higher-level, parameterized APIs that do not invoke a shell (for example, language-native Git libraries or process execution with argument arrays and shell=False equivalents)
  • Apply strict allowlists for all inputs that may influence system commands (e.g., repository URLs, paths), rejecting values that do not conform to an expected pattern
  • Normalize and validate filesystem paths and repository identifiers to prevent injection of shell metacharacters and unexpected expansions
  • Restrict or disable installer-related functionality in production environments, especially once initial setup is complete
  • Run the web application under a minimally privileged account, limiting OS-level damage if command injection does occur
  • Segment the CMS server from sensitive internal networks so a compromise has limited blast radius

How teams detect issues like this

Organizations can detect and monitor for this class of vulnerability using a combination of code-focused and operational techniques:

  • Static analysis rules to flag dynamic shell command construction functions (e.g., exec, system, shell_exec, backticks) where arguments contain user-controlled variables
  • Code review checklists that require reviewers to examine all uses of command execution APIs, verifying that user input is strictly validated and not passed through a shell
  • Automated security testing (SAST/DAST) integrated into CI pipelines to identify potential command injection patterns and anomalous web responses triggered by test payloads
  • Application logging and SIEM correlation to detect unusual command patterns, unexpected Git operations, or process invocation from the web server context
  • Configuration policies that disallow leaving installation or setup modules enabled in production, enforced via deployment pipelines or configuration management tools

Sources

SourceLink
github.comgithub.com/daylightstudio/FUEL-CMS/blob/master/fuel/modules/fuel/controllers/Installer.php
pentest-tools.compentest-tools.com/PTT-2025-028-Authenticated-RCE-via-Git-Submodules.pdf

Frequently asked

questions

Yes, if the FuelCMS instance is exposed over a network and the installer functionality is reachable to authenticated users, an attacker can exploit it remotely after obtaining valid credentials.

Exploitation is described as authenticated. The attacker needs a valid login and sufficient permissions to access the Installer.php controller and invoke add_git_submodule, but typically does not require OS-level privileges beforehand.

The safest approach is to remove reliance on shell invocation for Git operations and use parameterized, non-shell APIs instead. Additionally, restrict or disable installer routes in production, and ensure any remaining command execution paths apply strict input validation and do not pass unsanitized data into a shell.

Adopt a development standard that forbids building shell command strings with user input. Use safe process-execution primitives that take argument lists, enforce strict allowlists for any value that may reach the OS, perform regular security code reviews focused on command execution hotspots, and ensure installation/setup modules are decommissioned or locked down after deployment.

Find out what's already
exploitable in your codebase.