/

CVE-2026-24169

Severity:

HIGH RISK

(8.0)

Command Injection (CWE-77) in NVIDIA UFM Plugin API

CVE-2026-24169

Undergoing Analysis

Vulnerability type

Category:

Command Injection

CWE:

CWE-77

Impact:

Code Execution, Privilege Escalation, and Information Disclosure

Severity:

HIGH RISK

(8.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 UFM Enterprise contains a command injection vulnerability in its plugin management API. An authenticated, low-privileged user could submit a specially crafted request that may cause unintended code execution, privilege escalation, or information disclosure.

Affected context

The vulnerability occurs in deployments where the NVIDIA UFM Enterprise plugin management API is reachable by an authenticated user with limited privileges and request data is incorporated into command or code execution paths without sufficient isolation. Risk depends on the API being enabled, accessible to the user, and processing attacker-controlled plugin-related input.

Exploit preconditions

  • Attack surface: NVIDIA UFM Enterprise plugin management API
  • Required access: Authenticated account with low privileges
  • Trigger point: Processing of a specially crafted plugin management API request
  • Why exploitation is possible: Attacker-controlled input may reach an execution context without adequate command separation, validation, or neutralization

Why this happens

The underlying issue is an unsafe command construction pattern in which externally supplied API data can influence an operating-system command or executable expression. If input is concatenated into an execution path instead of being treated strictly as data, command separators or other control elements may alter the intended operation. This behavior maps to CWE-77: Improper Neutralization of Special Elements used in a Command ('Command Injection').

Potential impact

  • An attacker may execute unauthorized commands in the affected service context
  • The attacker could escalate privileges available to the service account
  • Sensitive system or application information may be disclosed
  • The UFM management environment could be modified or disrupted
  • Compromised privileges could enable further access to connected infrastructure

General mitigation guidance

Mitigation generally focuses on removing attacker-controlled input from command execution paths and reducing the privileges available to the affected service.

Common defensive patterns include:

  • Prefer direct library or API calls over shell command execution
  • Use fixed command and argument mappings rather than dynamic command construction
  • Treat plugin metadata and request fields as untrusted input
  • Apply strict allowlists and schema validation before processing plugin operations
  • Enforce contextual output and input encoding where execution cannot be avoided
  • Run management services with least-privilege identities and restricted filesystem access
  • Limit plugin API exposure through authentication, authorization, and network policy controls

How teams detect issues like this

Organizations can look for command injection risks through:

  • Static analysis rules identifying shell execution APIs and string concatenation involving request data
  • Code review checks for dynamic command construction in plugin or administrative functionality
  • Tests using benign metacharacter and boundary input to verify that values remain data
  • Runtime monitoring for unexpected child processes, shell interpreters, or command execution by the UFM service
  • API policy enforcement that restricts plugin operations to approved methods and validated schemas
  • Automated security review tools that flag untrusted data flows into process-spawning functions

Sources

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

Frequently asked

questions

It may be exploitable through the plugin management API when that interface is reachable and the attacker can authenticate with an account possessing the required low-level privileges.

No. The described condition requires authentication with a low-privileged account, although the exact permissions needed may depend on deployment configuration and API authorization.

Avoid constructing shell commands from API input. Prefer fixed operations and native library interfaces, combined with strict allowlists, schema validation, and least-privilege execution.

Treat all API fields as untrusted, enforce authorization at each plugin operation, review data flows into process execution APIs, and monitor management services for unexpected child-process activity.

Find out what's already
exploitable in your codebase.