/

CVE-2026-65082

Severity:

HIGH RISK

(7.0)

Code Injection (CWE-94) in NVIDIA NemoClaw for Linux

CVE-2026-65082

Analyzed

Vulnerability type

Category:

Code Injection

CWE:

CWE-94

Impact:

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

Severity:

HIGH RISK

(7.0)

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 a code-injection vulnerability in its migration command. A local attacker who can invoke or influence the affected migration operation may be able to execute code, tamper with data, disclose information, or disrupt service.

Affected context

The vulnerability occurs in the migration functionality of NVIDIA NemoClaw for Linux. It becomes risky when a local, potentially lower-privileged user can reach the migration command and provide or influence data that the command processes in an executable context. The exact exposure depends on how migration operations are authorized and how input is handled by the deployment.

Exploit preconditions

  • Attack surface: The NemoClaw migration command on a Linux system
  • Required access: Local access sufficient to invoke the command or influence its migration inputs
  • Trigger point: Processing of attacker-influenced data during migration
  • Why exploitation is possible: Input is handled in a way that can cause injected content to be interpreted as executable code

Why this happens

The underlying bug is an unsafe code-generation or code-evaluation pattern in migration processing. Instead of treating migration data strictly as inert data, the affected logic may allow attacker-controlled content to cross into an execution context. This behavior maps to CWE-94, Improper Control of Generation of Code, because external input can influence code that the application executes.

Potential impact

  • An attacker may execute code with the privileges of the NemoClaw process.
  • An attacker could tamper with application or migration data.
  • Sensitive information could be disclosed.
  • The system or migration service could experience denial of service.
  • A compromise could enable further actions within the local account's permissions.

General mitigation guidance

Mitigation generally focuses on ensuring migration inputs remain data rather

than executable content.

Common defensive patterns include:

  • Replacing dynamic evaluation, shell construction, or generated-code paths with structured, non-executable processing.
  • Applying strict schemas, type checks, and allowlists to migration inputs.
  • Reducing input trust by separating user-controlled data from command and code construction.
  • Running migration operations with the minimum required operating-system privileges.
  • Restricting which users and services can invoke migration commands.
  • Isolating migration jobs and limiting filesystem, network, and process access where practical.

How teams detect issues like this

Organizations can look for this weakness through:

  • Static analysis rules identifying dynamic evaluation, unsafe command construction, and generated-code execution in migration paths.
  • Code review checks for string concatenation or interpolation that crosses from migration input into executable APIs.
  • Tests using malformed and metacharacter-containing inputs to verify that data is never interpreted as code.
  • Audit records for migration command invocation, unexpected child processes, and unusual file or network activity.
  • CI policy enforcement requiring input schemas, execution-boundary reviews, and least-privilege validation.

Automated code-review and software-composition tools may help identify related patterns, but should supplement manual review.

Sources

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

Frequently asked

questions

The description identifies a local attack path. Remote exploitation would generally

require an additional mechanism that provides local access or exposes the migration

functionality through a remotely reachable service.

An attacker needs local access sufficient to invoke the migration command or influence

the data it processes. The practical privilege requirement depends on deployment and

command authorization settings.

Treat migration input as data only: remove dynamic code execution and unsafe command

construction, then enforce strict schemas and allowlists at the parsing boundary.

Review migration and maintenance commands for execution-boundary crossings, apply

least privilege, restrict command access, and use automated tests and static policies

that detect dynamic evaluation and injection-prone patterns.

Find out what's already
exploitable in your codebase.