/

CVE-2026-34109

Severity:

CRITICAL RISK

(9.8)

OS Command Injection (CWE-78) in Guardian speech.php

CVE-2026-34109

Deferred

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution on Server

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 passed directly into a PHP exec() call without sanitization.

An unauthenticated remote attacker can exploit this by appending shell metacharacters to the id parameter, leading to arbitrary command execution on the server whenever speech.php is invoked.

Affected context

This vulnerability occurs in the Guardian language-system within the speech.php endpoint, which invokes a PHP script using exec().

The id value from the HTTP GET query string is concatenated directly into a shell command alongside the current login session identifier.

In deployments where speech.php is exposed over the network without strict input validation, command filtering, or additional authentication, the risk is significantly elevated.

Exploit preconditions

  • Attack surface: Public or internal web endpoint at speech.php accepting an id GET parameter
  • Required access: No prior authentication; a network path to the web server is sufficient
  • Trigger point: A crafted HTTP request that sets id to a value containing shell metacharacters (e.g., command separators)
  • Why exploitation is possible: The application constructs a shell command string by concatenating untrusted input and passes it directly to PHP's exec() function, allowing the shell to interpret attacker-controlled tokens as additional commands.

Why this happens

The root cause is the direct use of untrusted user input in a shell command, executed via PHP's exec() function, without any validation, escaping, or parameterization.

This pattern maps to CWE-78: Improper Neutralization of Special Elements used in an OS Command, where external input is incorporated into a command line and interpreted by the operating system.

Instead of using safer APIs or limiting input to strictly validated data, the code builds a command string that the shell parses, enabling an attacker to inject metacharacters and alter the intended behavior.

Potential impact

  • Remote attackers may execute arbitrary OS commands under the web server's privileges.
  • Attackers could read, modify, or delete application and system files accessible to the web process.
  • The system can be leveraged to install backdoors, cryptocurrency miners, or other malware.
  • Compromised servers may be used as a pivot point for lateral movement inside the network.
  • Sensitive data, such as configuration files or user data, could be exfiltrated.

General mitigation guidance

Effective mitigation focuses on removing direct shell command construction from untrusted data paths and reducing what the web process can do if compromised.

Common defensive patterns include:

  • Replacing exec() and similar shell-invoking functions with safer, parameterized APIs or dedicated library calls that do not spawn a shell.
  • Strictly validating and constraining input parameters to well-defined formats (e.g., numeric IDs, whitelisted tokens) before use.
  • Applying robust output escaping or argument-quoting routines when a shell call is genuinely unavoidable, ensuring special characters cannot alter command structure.
  • Implementing least-privilege execution for the web server account, restricting file system and network access.
  • Isolating risky functionality into separate, tightly scoped services or worker processes with minimized privileges.

How teams detect issues like this

Detection generally relies on identifying insecure command construction patterns and monitoring for abnormal runtime behavior.

Typical strategies include:

  • Static analysis rules that flag usage of exec(), system(), shell_exec(), passthru(), and backticks where arguments include direct user input.
  • Code review checklists focusing on any function that spawns shell commands, verifying that all arguments are validated and not derived from raw HTTP parameters.
  • Application security testing (DAST) that injects shell metacharacters into parameters like id and observes server responses or side effects.
  • Runtime monitoring and intrusion detection that looks for unusual child processes spawned by the web server, unexpected command lines, or anomalous system activity.

Sources

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

Frequently asked

questions

Yes. Because the vulnerable parameter is exposed via an HTTP GET request and processed by exec(), a remote attacker can directly influence system-level commands executed on the server, potentially impacting the broader host environment.

No. The vulnerable speech.php endpoint uses the id parameter without authentication, so any party with network access to the endpoint can attempt exploitation.

The safest fix is to avoid constructing shell commands from request parameters and instead use higher-level, parameterized APIs or internal function calls that perform the needed operation without invoking a shell. If a shell call is unavoidable, strictly validate the allowed input set and correctly escape or quote arguments.

Preventive practices include establishing coding standards that discourage direct shell invocation, enforcing systematic input validation, using automated security scanning to detect dangerous patterns, and performing regular security-focused code reviews on endpoints that handle user input or execute system-level actions.

Find out what's already
exploitable in your codebase.