/

CVE-2026-34106

Severity:

CRITICAL RISK

(9.8)

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

CVE-2026-34106

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 the id GET parameter is passed directly into a PHP exec() call without sanitization or validation.

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

Affected context

This vulnerability occurs in the Guardian language-system within subtitles.php, where user-controlled data from the id GET parameter is concatenated into a shell command executed via PHP exec().

The issue is present when the application exposes subtitles.php over HTTP without strict input validation, output encoding, or command argument escaping, and when the underlying PHP process has sufficient OS-level privileges for the executed commands to have meaningful impact.

Exploit preconditions

  • Attack surface: Publicly accessible subtitles.php endpoint over HTTP/HTTPS
  • Required access: No authentication; attacker only needs network access to the web application
  • Trigger point: Supplying a crafted id query parameter that is incorporated into the exec("php jobs/subtitle_rendering.php ...") call
  • Why exploitation is possible: The application directly concatenates untrusted input into a shell command without sanitization, escaping, or argument-level boundary enforcement, allowing shell metacharacters to alter command behavior

Why this happens

The underlying bug class aligns with CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection').

In subtitles.php, the application constructs a command string that includes the id GET parameter and passes it to PHP exec(), effectively treating user input as part of a shell command.

Because special shell characters are not filtered, escaped, or isolated as safe arguments, the shell interprets them as control syntax, enabling attackers to inject additional commands or alter the intended execution flow.

Potential impact

  • Remote attackers may execute arbitrary OS commands with the privileges of the web server user
  • Attackers could read, modify, or delete application and system files accessible to the PHP process
  • The system could be co-opted to install malware, backdoors, or pivot tools for lateral movement
  • Attackers may exfiltrate sensitive data such as configuration files, credentials, or user information
  • The server can be abused for denial-of-service, cryptomining, or participation in broader attack campaigns

General mitigation guidance

Effective mitigation focuses on eliminating direct concatenation of untrusted input into shell commands and reducing the privileges of command execution environments.

Pattern-based defensive strategies include:

  • Avoiding shell invocation when possible, favoring safe APIs or internal function calls that do not interpret shell syntax
  • If command-line tools are necessary, using argument-based execution (e.g., exec with array arguments or dedicated libraries) that separate data from command structure
  • Applying strict validation on all user-supplied parameters, constraining id to expected formats (such as numeric IDs or fixed tokens)
  • Enforcing least-privilege for the web server and PHP processes so that, if exploited, the resulting impact is limited
  • Centralizing input-handling policies to ensure consistent sanitization and validation across endpoints

How teams detect issues like this

Detection typically involves a combination of code-focused and runtime techniques.

Common strategies include:

  • Static analysis rules that flag uses of exec(), shell_exec(), system(), or similar APIs where user input is concatenated into command strings
  • Code review checklists emphasizing the separation of command logic from user-controlled data and discouraging shell-based implementations for routine tasks
  • Application security policies that require justification and additional review for any OS-level command execution within web applications
  • Runtime monitoring and logging of command execution patterns, alerting on abnormal arguments or unexpected command sequences

Sources

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

Frequently asked

questions

Yes, if subtitles.php is exposed over HTTP/HTTPS and accessible from external networks, an attacker can send crafted requests to exploit the command injection without prior authentication.

The vulnerability is reachable by any party that can make web requests to the affected endpoint; no local access or credentials are required, only network connectivity to the application.

The safest approach is to remove direct shell command usage for user-driven operations, implement equivalent functionality using safe language constructs or libraries, and strictly validate and constrain any data that must be passed as command arguments.

Establish development guidelines that prohibit the use of shell-executing APIs with untrusted input, adopt centralized input validation routines, integrate static analysis into the CI pipeline to flag dangerous patterns, and train developers to recognize injection risks whenever user data intersects with interpreters or system-level interfaces.

Find out what's already
exploitable in your codebase.