/

CVE-2026-32298

Severity:

CRITICAL RISK

(9.1)

OS Command Injection in Angeet ES3 KVM cfg.lua

CVE-2026-32298

Analyzed

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.1)

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

Angeet ES3 KVM contains an OS command injection flaw in the cfg.lua script, where user-supplied variables are passed to the underlying operating system without proper sanitization.

An authenticated attacker who can reach the vulnerable configuration interface may execute arbitrary system commands with the privileges of the KVM management process.

Affected context

The vulnerability exists in the Angeet ES3 KVM management environment where the cfg.lua script processes configuration parameters provided by authenticated users.

When user-controlled variables are incorporated into shell commands without rigorous validation or escaping, the KVM's management interface becomes a vehicle for arbitrary command execution.

This typically arises in web or API-based configuration flows that map request parameters directly into system-level utilities or scripts.

Exploit preconditions

  • Attack surface: Network-accessible management interface of the Angeet ES3 KVM.
  • Required access: Valid authenticated access to the configuration functionality that invokes cfg.lua.
  • Trigger point: Submission of crafted configuration values or parameters that are subsequently processed by cfg.lua and passed to the OS shell.
  • Why exploitation is possible: The script embeds user-controlled input directly into OS command strings (or equivalent facilities) without adequate input validation, escaping, or use of safe command execution APIs, enabling injection of additional shell syntax.

Why this happens

This issue stems from cfg.lua treating user-supplied input as trusted when constructing OS-level commands.

Instead of separating data from command logic or using parameterized, API-level calls, the script likely concatenates or interpolates variables into shell command strings.

This pattern aligns with CWE-78: Improper Neutralization of Special Elements used in an OS Command, where lack of neutralization of metacharacters (such as ;, &&, |, or backticks) lets attackers alter the command's structure.

The core problem is the absence of strict input validation and the reliance on shell interpretation rather than safer, structured system APIs.

Potential impact

  • Execution of arbitrary OS commands with the privileges of the KVM management process.
  • Complete compromise of the KVM device, including configuration, logging, and attached console sessions.
  • Extraction or manipulation of sensitive data stored on or accessible through the KVM.
  • Use of the compromised KVM as a pivot point for lateral movement within the management or data center network.
  • Disruption of KVM operations, including denial of service or forced reboots.

General mitigation guidance

Effective mitigation focuses on eliminating direct command construction from user-controlled input and hardening the configuration interface:

  • Refactor cfg.lua to use high-level, parameterized system APIs or libraries instead of shelling out to execute commands.
  • Apply strict allowlists for expected parameter formats (e.g., specific patterns for hostnames, IP addresses, or flags) and reject or sanitize anything outside the defined schema.
  • Normalize and validate all configuration values before use, discarding input containing shell metacharacters or unexpected tokens.
  • Enforce least-privilege execution for the KVM management process so that, if command execution occurs, its blast radius is reduced.
  • Limit the capabilities exposed by configuration endpoints to the minimum necessary for operation, avoiding direct mapping to powerful system utilities.

These patterns aim to reduce trust in user input and remove opportunities for it to influence OS-level command structure.

How teams detect issues like this

Organizations can look for this class of vulnerability using a combination of code review and automated analysis:

  • Static analysis: Define rules that flag string concatenation or interpolation where user-controlled variables are passed into shell execution primitives (e.g., os.execute, io.popen, or similar Lua bindings).
  • Code review: During reviews, pay special attention to scripts like cfg.lua that bridge web/API inputs with system commands, verifying that they use allowlists, escaping, and safe APIs.
  • Dynamic testing: Use security testing tools or manual penetration testing to submit crafted configuration inputs containing command separators to observe unexpected behavior.
  • Policy enforcement: Require that all configuration paths invoking system commands follow predefined secure coding guidelines (e.g., no raw shell invocation from request parameters) and incorporate these checks into CI/CD pipelines.

Automated SAST/DAST tools, combined with manual review, are well suited to reveal unsafe command construction patterns in such management scripts.

Sources

SourceLink
eclypsium.comeclypsium.com/blog/kvm-devices-the-keys-to-your-kingdom-are-hanging-on-the-network/
raw.githubusercontent.comraw.githubusercontent.com/cisagov/CSAF/develop/csaf_files/IT/white/2025/va-26-076-01.json
cve.orgcve.org/CVERecord?id=CVE-2026-32291

Frequently asked

questions

Exploitability is typically limited to authenticated users who can access the vulnerable configuration functionality. However, in environments where many administrators have access or credentials are weakly protected, the practical exposure can still be significant.

The attacker must be authenticated to the KVM's management interface with whatever role is allowed to invoke cfg.lua-based configuration operations. If standard user roles can access this functionality, the barrier to exploitation is lower.

The most robust fix is to remove direct shell command construction from cfg.lua and instead use safe, parameterized system APIs or libraries. Alongside that, enforce strict schema-based validation and allowlists for every configuration parameter before it is used.

Adopt secure coding guidelines that forbid passing user input directly to shells, mandate input validation and normalization for all configuration fields, and require security-focused code reviews for any script or component that interfaces with the operating system. Integrating static analysis and automated security checks into the development lifecycle helps catch command injection patterns early.

Find out what's already
exploitable in your codebase.