/

CVE-2026-65089

Severity:

HIGH RISK

(7.8)

OS Command Injection (CWE-78) in NemoClaw Status Plugin

CVE-2026-65089

Analyzed

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Code Execution, Data Tampering, Information Disclosure, and Denial of Service

Severity:

HIGH RISK

(7.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

NVIDIA NemoClaw for Linux contains an OS command injection vulnerability in status and logs plugin commands. If attacker-controlled input reaches the affected command-handling path, successful exploitation could enable code execution, data tampering, information disclosure, or denial of service.

Affected context

The vulnerability occurs in NVIDIA NemoClaw for Linux within functionality that processes status and logs plugin commands. Risk depends on whether untrusted or insufficiently validated input can reach these commands and whether the executing process has meaningful operating-system permissions.

Exploit preconditions

  • Attack surface: Status and logs plugin command-handling interfaces
  • Required access: The ability to invoke the affected functionality or provide data that it processes
  • Trigger point: Processing of attacker-influenced command arguments or related input
  • Why exploitation is possible: Input may be incorporated into an operating-system command without adequate separation, validation, or neutralization

Why this happens

The underlying bug is an OS command injection flaw mapped to CWE-78. The application appears to construct or invoke operating-system commands using data that may be influenced by an attacker, allowing that data to alter command interpretation rather than being treated solely as a value. This insecure pattern can cause unintended commands or command arguments to execute with the privileges of the NemoClaw process.

Potential impact

  • An attacker could execute arbitrary code in the NemoClaw process context.
  • System or application data could be modified or tampered with.
  • Sensitive information could be disclosed.
  • The service could become unavailable through denial-of-service conditions.
  • Compromise could enable further access depending on process privileges and surrounding controls.

General mitigation guidance

Mitigation generally focuses on removing shell interpretation from application workflows and reducing trust in command-related input.

Common defensive patterns include:

  • Prefer direct process APIs with fixed executables and structured argument arrays instead of shell-evaluated command strings.
  • Apply allowlists and strict type, length, and format validation to values used by plugin commands.
  • Avoid deriving executable names, options, or command fragments from untrusted input.
  • Run NemoClaw components with the least privileges required and isolate them from sensitive host resources.
  • Use operating-system confinement, restricted service accounts, and filesystem permissions to limit consequences.
  • Preserve safe defaults when validation fails rather than attempting to execute partially validated input.

How teams detect issues like this

Organizations can look for command injection risks through:

  • Static analysis rules that identify shell invocation APIs, command-string concatenation, and interpolation of external input.
  • Code review checks for plugin arguments, status parameters, and log-related values flowing into process execution.
  • Runtime monitoring of unexpected child processes, unusual command-line arguments, and executions originating from NemoClaw components.
  • Policy enforcement requiring direct process execution, approved binaries, and validated argument schemas.
  • Automated security review tools that flag tainted data reaching shell or operating-system command interfaces.

Sources

SourceLink
github.comgithub.com/NVIDIA/product-security/tree/main/2026/5872
nvd.nist.govnvd.nist.gov/vuln/detail/CVE-2026-65089
cve.orgcve.org/CVERecord?id=CVE-2026-65089

Frequently asked

questions

Exploitability depends on how the status and logs plugin commands are exposed and whether an attacker can supply input to them. A network-reachable or otherwise externally accessible command interface could broaden the attack scope.

The attacker generally needs a way to invoke the affected plugin functionality or influence data consumed by it. The practical requirement depends on NemoClaw deployment, authentication, and authorization controls.

Avoid shell-based command construction. Use fixed executables with structured arguments, validate all externally influenced values against narrow allowlists, and ensure failures do not trigger execution.

Combine secure process-execution APIs with least-privilege service accounts, strict authorization, static analysis, code review, and runtime monitoring for unexpected child-process activity.

Find out what's already
exploitable in your codebase.