/

CVE-2026-34113

Severity:

CRITICAL RISK

(9.8)

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

CVE-2026-34113

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 unauthenticated OS command injection flaw in speech_text.php, where a user-supplied GET parameter is passed directly to PHP's exec() function without sanitization.

By appending shell metacharacters to the id parameter, a remote attacker can execute arbitrary commands on the underlying server in the context of the web application.

Affected context

The vulnerability occurs in the Guardian language-system web application within speech_text.php, which invokes a background PHP script using the exec() function.

The id parameter from the HTTP GET query string is concatenated directly into the shell command, alongside a session-related variable, without escaping, validation, or authentication checks.

Any deployment that exposes this endpoint over HTTP or HTTPS and uses a shell to interpret the exec() call is potentially affected.

Exploit preconditions

  • Attack surface: Public-facing HTTP endpoint (speech_text.php) accessible over the network.
  • Required access: No prior authentication; any user capable of sending crafted GET requests can reach the vulnerable parameter.
  • Trigger point: Invocation of speech_text.php with a malicious id value, causing exec("php jobs/speech_audio_text.php ".$login_session." ".$_GET['id']." ...") to execute.
  • Why exploitation is possible: The id parameter is concatenated directly into a shell command, allowing shell metacharacters to break out of the intended argument and inject arbitrary commands (classic OS command injection as per CWE-78).

Why this happens

The root cause is the direct interpolation of untrusted user input into a command line string executed by PHP's exec() function.

Instead of treating id as data, the code constructs a shell command by string concatenation and relies on the shell to parse it.

This design maps directly to CWE-78: Improper Neutralization of Special Elements used in an OS Command, where shell metacharacters in user-controllable input are not neutralized, enabling unintended command execution.

More broadly, it reflects an insecure pattern of mixing control and data in command construction, without validation, escaping, or the use of safer APIs that avoid shell parsing.

Potential impact

  • Remote execution of arbitrary OS commands in the security context of the web server process.
  • Reading, modifying, or deleting application and system files accessible to the web server user.
  • Planting web shells or backdoors, enabling persistent compromise of the server.
  • Exfiltration of sensitive data such as configuration files or credentials.
  • Lateral movement within the hosting environment or internal network, depending on network reachability and permissions.
  • Service disruption or denial of service by stopping services, consuming resources, or corrupting critical files.

General mitigation guidance

Effective mitigation focuses on eliminating direct command construction with untrusted input and reducing the reliance on shell interpretation.

Recommended defensive patterns include:

  • Avoid shell-based exec-style APIs when possible; prefer language-native functions or libraries that perform the required action without invoking a shell.
  • When executing external programs is unavoidable, use APIs that pass arguments as arrays or separate parameters, so the shell is not involved in parsing.
  • Enforce strict validation on all user-controlled inputs, especially parameters used in command construction, using allowlists of expected formats (e.g., numeric IDs, fixed tokens).
  • Normalize and constrain input early in the request handling path, rejecting values that do not match well-defined patterns.
  • Apply least-privilege principles to the web server and any invoked processes, limiting filesystem and network access to reduce blast radius if a flaw occurs.
  • Centralize and standardize patterns for calling external processes, so security review can focus on a small, well-audited surface area.

How teams detect issues like this

Detection can combine code-focused analysis with runtime monitoring:

  • Static analysis: Configure rules to flag calls to exec(), system(), shell_exec(), passthru(), or backtick operators where arguments incorporate variables derived from request data (e.g., $_GET, $_POST, $_REQUEST) without prior sanitization or validation.
  • Code review: During manual review, search for shell command construction via string concatenation; pay particular attention to scripts that process request parameters or session values when building commands.
  • Security testing: Use dynamic application security testing (DAST) tools or manual penetration testing to probe endpoints with typical shell metacharacters and observe anomalous behavior or command execution artifacts.
  • Runtime monitoring: Instrument logging and monitoring for unusual child processes spawned by the web server, unexpected command lines, or anomalous outbound network connections originating from web application processes.
  • Policy enforcement: Adopt secure coding guidelines that restrict direct use of shell-execution APIs, backed by pre-commit hooks or CI checks that flag new usages for security review.

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-text-php

Frequently asked

questions

Yes. The vulnerable script is reachable via HTTP, and the id parameter in the query string can be controlled by any remote user, making it fully remote in nature.

No authentication is required. Any unauthenticated user who can send requests to the affected endpoint can attempt exploitation.

The most robust fix is to stop building shell commands from user input altogether: replace exec-based calls with direct PHP APIs or library functions that perform the necessary work without invoking a shell. If external processes must be called, pass arguments as separate parameters and apply strict input validation.

Establish coding standards that prohibit direct shell command construction with user input, enforce rigorous input validation and allowlisting, and use automated checks (static analysis, secure code review templates) to flag dangerous patterns early in development. Running services with least privilege and maintaining good logging also helps limit impact and aid detection.

Find out what's already
exploitable in your codebase.