/

CVE-2026-35682

Severity:

HIGH RISK

(8.8)

OS Command Injection in Anviz CX2 Lite Filename Parameter

CVE-2026-35682

Analyzed

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-77

Impact:

Remote Code Execution with Root Privileges

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

Anviz CX2 Lite contains an authenticated OS command injection vulnerability in a filename parameter that is used to construct shell commands.

A logged-in attacker can inject arbitrary commands (such as starting telnetd), leading to remote code execution with root-level privileges on the device.

Affected context

This vulnerability occurs in the web-management or API interface of Anviz CX2 Lite where user-provided filename values are used in backend shell commands.

It manifests when the application concatenates or interpolates the filename parameter directly into a command string executed by the operating system without robust validation or safe APIs.

The issue is relevant in deployments where the management interface is reachable (e.g., from internal networks) and user accounts can be provisioned or compromised.

Exploit preconditions

  • Attack surface: Authenticated web or API endpoint on the Anviz CX2 Lite device that accepts a filename parameter.
  • Required access: Valid credentials or a hijacked authenticated session with sufficient privileges to reach the affected functionality.
  • Trigger point: Submission of a crafted filename value that gets passed into an underlying shell command on the device.
  • Why exploitation is possible: The backend builds OS command strings using untrusted input from the filename parameter without proper escaping, quoting, or use of command-safe APIs, allowing shell metacharacters to alter command flow.

Why this happens

The root cause maps to CWE-77: Improper Neutralization of Special Elements used in a Command ('Command Injection').

The application constructs shell commands that include the user-supplied filename parameter, likely via string concatenation or formatting.

Because shell metacharacters (such as separators, redirection operators, or command substitution syntax) are not fully neutralized and no command-safe API is used, the shell interprets parts of the filename as additional commands.

This pattern turns what should be simple data (a filename) into executable control input, enabling arbitrary OS command execution under the privileges of the web process (root on this device).

Potential impact

  • Remote execution of arbitrary OS commands on the device as root.
  • Enabling additional services (e.g., starting telnetd/other daemons) that expand the attack surface.
  • Full compromise of device configuration, logs, and stored credentials or keys.
  • Use of the device as a pivot point for lateral movement within the local network.
  • Installation of persistent malware or backdoors on the device firmware or filesystem.
  • Disruption of normal device functionality, including denial of service.

General mitigation guidance

Effective mitigation focuses on treating all parameters used in shell commands as untrusted and removing direct shell composition where possible.

Recommended patterns include:

  • Replacing shell-based operations with dedicated system APIs or library calls that accept arguments as structured parameters rather than command strings.
  • Strictly validating the filename parameter against an allowlist of permitted characters and patterns (e.g., alphanumeric plus a small set of safe symbols) and rejecting anything else.
  • Normalizing and constraining file paths to known directories and avoiding any dynamic inclusion of shell syntax.
  • Using safe process execution primitives that bypass the shell (e.g., APIs that pass arguments as arrays) and disable interpretation of metacharacters.
  • Running the web or management service under a dedicated, least-privilege account instead of root, and limiting what commands or files it can access.
  • Hardening management access by restricting network exposure (e.g., internal segments, VPN) and enforcing strong authentication hygiene to reduce attacker access to the vulnerable interface.

How teams detect issues like this

Detection approaches commonly combine code-level analysis with behavioral monitoring:

  • Static analysis: Search for code that builds command strings including user-controlled parameters such as filename, especially where shell invocation functions are used with concatenated strings.
  • Code review: Flag any use of shell commands for routine file operations, paying attention to string interpolation, absence of allowlist validation, and reliance on escaping or blacklists.
  • Policy enforcement: Adopt secure coding standards that prohibit direct shell calls from web handlers unless absolutely necessary and require justification and review.
  • Runtime monitoring: Use logging to capture executed commands and unusual service activations (e.g., unexpected telnetd startup) and alert on anomalous patterns indicative of injected parameters.
  • Automated security testing tools, including SAST and DAST, can be configured to detect command injection patterns and probe parameterized endpoints for injection behavior during CI/CD.

Sources

SourceLink
github.comgithub.com/cisagov/CSAF/blob/develop/csaf_files/OT/white/2026/icsa-26-106-03.json
anviz.comanviz.com/contact-us.html
cisa.govcisa.gov/news-events/ics-advisories/icsa-26-106-03

Frequently asked

questions

Yes, if the management or API interface of the Anviz CX2 Lite is network-accessible and an attacker can authenticate, they can send crafted requests to exploit the command injection.

Exploitation, as described, requires authenticated access to the affected interface. However, any compromise of user credentials (weak passwords, reused passwords, or other vulnerabilities) can satisfy this requirement.

The safest pattern is to eliminate shell-based command construction entirely for operations involving user input, using safe system APIs or libraries that accept arguments as structured parameters. Where shell usage is unavoidable, apply strict allowlist validation on inputs and use process execution functions that avoid invoking a shell.

Design the system so that user input is never directly included in command strings, enforce character and pattern allowlists on all inputs that may reach sensitive APIs, follow least-privilege principles for service accounts, and incorporate automated security checks (SAST/DAST) and security-focused code reviews into the development lifecycle.

Find out what's already
exploitable in your codebase.