/

CVE-2026-72551

Severity:

HIGH RISK

(8.8)

OS Command Injection (CWE-78) in Apioo Fusio Server

CVE-2026-72551

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

Apioo Fusio contains a PHP sandbox allow-list bypass that can permit transitive access to functions capable of invoking operating-system commands. An authenticated user with the Developer role may exploit this weakness to execute arbitrary commands and potentially compromise the server.

Affected context

The vulnerability occurs in Apioo Fusio deployments that expose PHP sandbox functionality to authenticated Developer-role users. It becomes risky when the sandbox allow-list permits functions whose call paths can reach command-execution primitives, allowing code to escape the intended execution restrictions.

Exploit preconditions

  • Attack surface: PHP sandbox functionality exposed through the Fusio application
  • Required access: An authenticated account with the Developer role
  • Trigger point: Processing or execution of developer-controlled sandbox logic
  • Why exploitation is possible: The allow-list restricts direct functions but does not sufficiently account for transitive calls that can reach operating-system command execution

Why this happens

The underlying flaw is an incomplete sandbox allow-list that evaluates permitted functions without adequately modeling the operations they can invoke indirectly. This creates a path from apparently allowed PHP functionality to system command execution, matching CWE-78: Improper Neutralization of Special Elements used in an OS Command. The insecure pattern is treating function allow-listing as a complete security boundary without enforcing capability isolation or blocking dangerous call chains.

Potential impact

  • An attacker may execute arbitrary operating-system commands
  • The application server could be fully compromised
  • Confidential data may be accessed or modified
  • Application credentials and environment secrets could be exposed
  • The compromised host could be used for lateral movement or persistent access

General mitigation guidance

Mitigation generally focuses on removing command-execution capabilities from sandboxed code and reducing reliance on application-level allow-lists as security boundaries.

Common defensive patterns include:

  • Use a deny-by-design execution model with narrowly scoped, non-transitive capabilities
  • Prevent sandboxed code from reaching process, filesystem, shell, and operating-system interfaces
  • Execute untrusted developer logic in isolated workers with minimal privileges and restricted network access
  • Apply strict role and tenant separation so Developer accounts receive only required capabilities
  • Treat developer-provided code and configuration as untrusted input
  • Enforce resource, filesystem, and process isolation at the operating-system or container boundary

How teams detect issues like this

Organizations can look for this weakness through:

  • Static analysis rules identifying sandbox allow-lists that include filesystem, process, shell, or dynamic invocation capabilities
  • Code review checks that trace permitted functions through indirect and transitive call paths
  • Tests that verify sandboxed code cannot access operating-system command APIs
  • Runtime monitoring for unexpected child processes, shell activity, or commands launched by application workers
  • Policy enforcement requiring untrusted code to run in isolated, least-privileged environments
  • Automated security review tools that flag dangerous PHP functions and incomplete sandbox boundaries

Sources

SourceLink
github.comgithub.com/apioo/fusio

Frequently asked

questions

It may be exploitable through the application's exposed sandbox functionality when the attacker can authenticate with a Developer-role account and reach the affected execution path.

Exploitation requires authenticated access with Developer-level permissions. The practical scope also depends on whether those accounts can submit or execute sandboxed logic.

Remove operating-system command capabilities from the sandbox and enforce isolation outside the application process rather than relying only on an allow-list.

Model indirect call paths during security reviews, use deny-by-default capabilities, apply least privilege, and test sandbox boundaries against filesystem, process, and shell access.

Find out what's already
exploitable in your codebase.