/

CVE-2026-34110

Severity:

CRITICAL RISK

(9.8)

OS Command Injection (CWE-78) in Guardian PHP exec()

CVE-2026-34110

Deferred

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.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

Guardian language-system contains an OS command injection flaw where a user-supplied GET parameter is concatenated into a PHP exec() call without sanitization.

An unauthenticated remote attacker can append shell metacharacters via the id parameter to execute arbitrary operating system commands on the server.

Affected context

This vulnerability occurs in the Guardian language-system within complex_start.php, where the id GET parameter is passed directly into a PHP exec() invocation.

It is relevant in deployments that expose this script over HTTP without protective filters or access controls, and where PHP can spawn shell processes.

The risk is elevated when the underlying OS account running the web server has broad filesystem or system-level privileges.

Exploit preconditions

  • Attack surface: HTTP endpoint invoking complex_start.php
  • Required access: None; exploitable by any unauthenticated remote user with network access to the application
  • Trigger point: Supplying crafted values in the id GET parameter that reach the exec("php jobs/complex.php ...") call
  • Why exploitation is possible: The application concatenates unvalidated, unescaped user input into a shell command string, allowing shell metacharacters to alter command execution flow

Why this happens

The root cause aligns with CWE-78: Improper Neutralization of Special Elements used in an OS Command, commonly called OS command injection.

In complex_start.php, user-controlled data from $_GET['id'] is directly embedded into a shell command passed to PHP's exec() without validation, escaping, or argument separation.

This insecure pattern lets attackers inject additional shell syntax (such as pipes, separators, or command substitution), causing the interpreter to execute arbitrary commands instead of just the intended job script.

Potential impact

  • Remote execution of arbitrary OS commands under the web server's user account
  • Reading, modifying, or deleting application and system files
  • Installing backdoors or malware on the server
  • Lateral movement to other internal systems from the compromised host
  • Full system takeover if the web server runs with elevated privileges

General mitigation guidance

Mitigation focuses on removing direct shell command construction from user input and minimizing command execution capabilities.

Recommended defensive patterns include:

  • Avoiding shell-based command execution in favor of safer language-native APIs that pass parameters as structured arguments instead of interpolated strings
  • Strictly validating and whitelisting allowed values for parameters such as id, rejecting or ignoring anything outside expected formats
  • Escaping and quoting any remaining dynamic content using robust command-argument APIs rather than manual string concatenation
  • Running the web server and application under least-privilege accounts with restricted filesystem and network access
  • Isolating job execution components (e.g., via worker queues or separate services) with narrowly scoped interfaces that do not accept raw shell fragments

How teams detect issues like this

Detection commonly relies on examining both code and runtime behavior:

  • Static analysis rules that flag uses of exec(), shell_exec(), system(), or similar APIs when they involve concatenated or unsanitized user input
  • Code review checklists highlighting direct use of command execution functions and verifying that inputs are validated and passed as discrete arguments
  • Runtime monitoring and logging for anomalous command patterns originating from web requests, such as unexpected binaries or shell metacharacters
  • Security policies in CI/CD pipelines that disallow high-risk command execution constructs unless explicitly justified and reviewed

Sources

SourceLink
gist.github.comgist.github.com/cyberinforepo/d5b2771d82e1b31b8fc1c33052e08dad
vulncheck.comvulncheck.com/advisories/guardian-language-system-unauthenticated-os-command-injection-via-id-parameter-in-complex-start-php

Frequently asked

questions

Yes. Any remote user who can send HTTP requests to the affected script can exploit the issue by crafting the id parameter, without needing prior authentication.

Only network access to the Guardian language-system endpoint running complex_start.php is required; no valid credentials or local access are needed.

Replace shell command execution with safer, native mechanisms that do not interpret user input as shell syntax, combined with strict allowlisting and validation of all parameters passed to backend jobs.

Establish coding standards that prohibit direct use of shell execution APIs with dynamic input, enforce input validation and least-privilege execution, and integrate automated checks in development workflows to flag risky patterns early.

Find out what's already
exploitable in your codebase.