CVE-2026-65130

Executive Summary

CVE-2026-65130 is an OS command injection vulnerability (CWE-78) in NVIDIA Infrastructure Controller for Linux, where an authenticated, highly privileged attacker can inject and execute arbitrary operating system commands. Successful exploitation may result in code execution, data tampering, denial of service, and information disclosure. The vulnerability is unpatched in all tracked sources, no public proof-of-concept or exploit code exists, and no affected version range has been published, leaving defenders without a version-scoped exposure list.

Technical Analysis

The NVD description states that NVIDIA Infrastructure Controller for Linux "contains a vulnerability where an attacker could cause OS command injection." CWE-78 denotes improper neutralization of special elements used in an OS command — meaning untrusted input reaches a command interpreter (shell or direct process invocation) without sufficient sanitization or parameterization, allowing attacker-controlled metacharacters, argument separators, or path fragments to be interpreted as commands rather than data.

What can be stated with confidence from the provided data:

• Vulnerability class: OS command injection (CWE-78).
• Impact class: Code execution, data tampering, denial of service, and information disclosure — a full loss of confidentiality, integrity, and availability on the affected component (reflected in C:H/I:H/A:H).
• Attack surface characteristics: Network-reachable (AV:N), no user interaction required (UI:N), and scope-changing (S:C), meaning a compromise of the vulnerable component can affect resources beyond its own security authority — consistent with a controller/orchestration component that manages other systems or executes privileged operations on them.
• Preconditions: High privileges required (PR:H) and high attack complexity (AC:H). The attacker must already hold an administrative or similarly privileged account on the controller, and exploitation likely depends on specific configuration state, timing, or input conditions that are not universally present.

What cannot be stated from the provided data: the specific command-execution entry point (web endpoint, CLI subcommand, API parameter, configuration field, or file path), the exact privilege boundary crossed, the injection syntax required, and the affected version range. No CNA title, vendor advisory, or patch reference was supplied. Any claim about a specific parameter name, URL path, or function would be fabricated and is therefore omitted.

The combination of PR:H and S:C is notable: the flaw is not a privilege-escalation primitive from an unprivileged position, but an escalation of impact from a privileged position. A controller administrator who would ordinarily be constrained to the controller's intended management functions can, via command injection, execute arbitrary code — potentially in a context that reaches managed infrastructure. This makes the vulnerability relevant to insider-threat and compromised-admin scenarios, and to defense-in-depth architectures where the controller is treated as a high-value pivot point rather than a trusted appliance.

The AC:H rating suggests exploitation is not a simple unauthenticated one-liner. Realistic explanations consistent with the CVSS profile include race conditions in command construction, context-dependent input handling, or the need to satisfy specific configuration prerequisites. Defenders should not read AC:H as "low risk" — it lowers exploitation likelihood but not impact.

Exploitation Scenarios

No public proof-of-concept or exploit code is available for CVE-2026-65130. The following attack chain is inferred strictly from the vulnerability class (CWE-78) and the published CVSS/impact profile. No specific endpoints, parameters, or function names are asserted because none are provided in the source data.

1. Reconnaissance and target identification. The attacker identifies an NVIDIA Infrastructure Controller for Linux instance reachable over the network (AV:N). Since no Shodan-verifiable product string or version range has been published, identification likely relies on organizational asset inventory, management-network enumeration, or fingerprinting the controller's management interface. The attacker must also determine that they can obtain or already possess the high level of privilege required (PR:H) — for example, an administrative account on the controller.

2. Triggering the flaw class. With privileged access, the attacker navigates to a controller function that constructs and executes an operating-system command from input the attacker can influence. In the OS command injection class, the classic trigger is supplying input containing shell metacharacters (command separators, substitution operators, pipelines, or argument-injection prefixes) into a field that is later concatenated into a command string executed by a shell. The high attack complexity (AC:H) implies that specific contextual conditions — configuration state, timing, or input-shape constraints — must align for the injected content to reach the interpreter intact.

3. Payload and execution. The injected content is interpreted by the underlying OS command interpreter rather than treated as inert data, resulting in execution of attacker-chosen commands with the privileges of the controller process that spawns the command. This is a vulnerability-class-level description; the exact payload syntax cannot be specified without the vendor advisory or source code.

4. Post-exploitation impact. Per the NVD description, outcomes include code execution, data tampering, denial of service, and information disclosure. Because the CVSS scope is Changed (S:C), the compromise is not necessarily contained to the controller itself — it may extend to resources or managed systems the controller is authorized to act upon, which is the primary reason this finding warrants elevated remediation priority despite AC:H.

Defenders should treat any authenticated controller session exhibiting anomalous child-process creation, unexpected shell invocation, or command-line arguments containing shell metacharacters as a potential exploitation attempt, regardless of whether a public PoC exists.

Impact Assessment

• Confidentiality: High. Information disclosure is explicitly listed as an exploit outcome; a command-execution primitive on a management/orchestration component can expose credentials, configuration, and telemetry handled by that component.
• Integrity: High. Data tampering is explicitly listed. Arbitrary command execution permits modification of controller state, configuration, and potentially data on systems under its authority.
• Availability: High. Denial of service is explicitly listed; command execution permits process termination, resource exhaustion, or destructive file operations.
• Scope: Changed. The exploited component's compromise can impact resources beyond its own security scope — the defining risk of a controller-class product. This elevates the effective blast radius from a single appliance to the managed estate it governs.
• Attack Vector: Network. Remotely reachable; no physical or adjacent-network requirement.
• Attack Complexity: High. Non-trivial preconditions; not reliably automatable without specific knowledge of the target's state.
• Privileges Required: High. Administrative access to the controller is a prerequisite, which significantly constrains the attacker population but does not eliminate insider, leaked-credential, or post-compromise-pivot scenarios.
• User Interaction: None. No victim action is needed once the preconditions are met.
• Base Score: 8.0 (High). The combination of S:C with H/H/H impacts produces a base score above the typical AV:N/AC:H/PR:H baseline; the Changed scope and maximal impact triad are what drive severity, not ease of exploitation.

Business impact. Organizations running NVIDIA Infrastructure Controller for Linux in data-center, AI-cluster, or GPU-fabric management roles should treat this as a high-priority finding. The controller is a trust anchor: compromise of it via command injection can translate into tampering with or disruption of the infrastructure it manages, plus exfiltration of the sensitive configuration and credential material such systems typically hold. Because the flaw is unpatched with no tracked vendor fix, the exposure window is open-ended; risk must be managed through network segmentation, privileged-access discipline, and monitoring until a fix is published.

Blast radius. Unknown version range means the full installed base of the product on Linux must be considered potentially affected. The Changed scope implies downstream systems are within the impact envelope.

Detection Guidance

Sigma Rule

title: Potential OS Command Injection Against NVIDIA Infrastructure Controller for Linux
id: 8f2c1d64-3b7e-4a90-9c15-5e0a7b1c2d33
status: experimental
description: Detects suspicious child-process creation consistent with OS command
  injection (CWE-78) on hosts running NVIDIA Infrastructure Controller for Linux.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-65130
author: valtersit.com
date: 2026/01/01
tags:
  - attack.t1190
  - attack.t1059.004
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentImage|endswith:
      - '/nvidia-infra-controller'
      - '/infra-controller'
      - '/nvcontroller'
  selection_shell:
    Image|endswith:
      - '/sh'
      - '/bash'
      - '/dash'
      - '/zsh'
  selection_flags:
    CommandLine|contains:
      - ';'
      - '&&'
      - '||'
      - '`'
      - '$('
      - '|'
      - '>'
      - 'wget '
      - 'curl '
      - 'nc '
      - 'base64 -d'
  condition: selection_parent and selection_shell and selection_flags
falsepositives:
  - Legitimate maintenance scripts invoked by controller administrators
  - Vendor-supplied health-check scripts using pipes or redirection
level: high

YARA Rule

rule CVE_2026_65130_OS_Command_Injection_NVIDIA_InfraController
{
    meta:
        description = "Detects shell metacharacter injection payloads targeting NVIDIA Infrastructure Controller for Linux (CWE-78, CVE-2026-65130)"
        author = "valtersit.com"
        date = "2026-01-01"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-65130"
        severity = "high"

    strings:
        $m1 = ";" ascii wide
        $m2 = "&&" ascii wide
        $m3 = "||" ascii wide
        $m4 = "$(" ascii wide
        $m5 = "`" ascii wide
        $m6 = "|" ascii wide
        $cap1 = "wget " ascii wide nocase
        $cap2 = "curl " ascii wide nocase
        $cap3 = "/bin/sh" ascii wide
        $cap4 = "/bin/bash" ascii wide
        $cap5 = "base64 -d" ascii wide nocase
        $word1 = "nvidia" ascii wide nocase
        $word2 = "infra" ascii wide nocase
        $word3 = "controller" ascii wide nocase

    condition:
        uint32be(0) == 0x7f454c46 or uint32be(0) == 0x213c6172 or true
        and 2 of ($cap*)
        and 1 of ($word*)
        and 1 of ($m*)
}

Suricata IDS Rule

alert tcp $HOME_NET any -> $EXTERNAL_NET any (msg:"CVE-2026-65130 Possible OS Command Injection Payload in NVIDIA Infrastructure Controller Traffic"; flow:to_server,established; content:"|3b|"; content:"|26|"; content:"|7c|"; content:"wget"; nocase; content:"|24 28|"; nocase; threshold: type limit, track by_src, count 5, seconds 60; classtype:attempted-admin; sid:1000651; rev:1; reference:cve,2026-65130; reference:url,nvd.nist.gov/vuln/detail/CVE-2026-65130;)

Elastic Detection

process where event.type == "start" and process.parent.name != null and
  process.parent.name in ("nvidia-infra-controller", "infra-controller", "nvcontroller") and
  process.name in ("sh", "bash", "dash", "zsh", "python", "perl") and
  (
    process.command_line like~ "*;*" or
    process.command_line like~ "*&&*" or
    process.command_line like~ "*||*" or
    process.command_line like~ "*$( *" or
    process.command_line like~ "*`*" or
    process.command_line like~ "*base64 -d*" or
    process.command_line like~ "*wget *" or
    process.command_line like~ "*curl *"
  )

Splunk SPL Query

index=linux sourcetype=linux_audit OR sourcetype=sysmon_linux (EventType=EXECVE OR event.category=process)
| search (parent_process_name IN ("nvidia-infra-controller","infra-controller","nvcontroller"))
| search (process_name IN ("sh","bash","dash","zsh","python","perl"))
| search (command_line="*;*" OR command_line="*&&*" OR command_line="*||*" OR command_line="*$(*" OR command_line="*`*" OR command_line="*wget *" OR command_line="*curl *" OR command_line="*base64 -d*")
| stats count min(_time) as first_seen max(_time) as last_seen values(command_line) as commands by host, user, parent_process_name
| where count >= 1
| convert ctime(first_seen) ctime(last_seen)
| sort - count

Wazuh OSSEC Rule

<group name="nvidia_infra_controller,cve-2026-65130,command_injection,">
  <rule id="100651" level="12">
    <if_sid>5920</if_sid>
    <field name="parent_process">nvidia-infra-controller|infra-controller|nvcontroller</field>
    <field name="process">sh|bash|dash|zsh</field>
    <field name="command_line" type="pcre2">(?i)(;|\&\&|\|\||\$\(|`|base64 -d|wget |curl )</field>
    <description>CVE-2026-65130: Possible OS command injection - shell spawned by NVIDIA Infrastructure Controller with metacharacter payload</description>
    <mitre>
      <id>T1190</id>
      <id>T1059.004</id>
    </mitre>
    <group>attack,command_injection,</group>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence is 0/4 — UNPATCHED. No vendor fix, advisory, workaround, or affected-version list was identified in any tracked source. The following guidance is therefore compensating-control oriented; it must be revisited as soon as NVIDIA publishes an advisory.

1) Immediate mitigations

• Restrict network access to the Infrastructure Controller management interface to a dedicated, tightly controlled administrative VLAN. The flaw is AV:N; reducing reachability directly reduces exposure to any actor lacking a foothold on that segment.
• Enforce least privilege on controller accounts. PR:H is a hard precondition — every account that does not genuinely require administrative rights on the controller should be downgraded, and shared/admin accounts eliminated.
• Apply phishing-resistant MFA to all controller administrative access to blunt credential-theft paths that would otherwise supply the required privilege.
• Remove or disable any controller functionality, integration, or configuration not actively required; if the injection point is reached through an optional management feature, closing that surface is an effective interim control.
• Treat the controller as a high-value trust boundary: constrain outbound network egress from the controller host to only the destinations it legitimately requires, limiting the utility of a successful code-execution primitive for lateral movement or data exfiltration.
• Increase log retention and forwarding for controller hosts and their downstream managed systems; with no PoC in the wild, detection is the primary compensating control until a patch lands.

2) Patch/upgrade steps

• Monitor NVIDIA's security bulletin channel and the NVD entry for CVE-2026-65130 for the vendor advisory, the fixed version, and the affected-version matrix. None is currently published.
• Once a fixed version is available, inventory all NVIDIA Infrastructure Controller for Linux deployments, prioritize internet- or broadly-reachable instances and any instance with elevated trust over downstream systems, and schedule upgrade in a maintenance window.
• Because scope is Changed (S:C), also review and rotate credentials, tokens, and configuration secrets handled by any controller suspected of compromise — remediation of the binary alone does not undo pre-patch credential exposure.
• Re-validate compensating controls after patching; segmentation and privilege reductions should generally remain in place as defense-in-depth.

3) Long-term hardening

• Adopt strict input-handling standards for command construction in management-plane software: avoid shell invocation entirely in favor of argument-vector process execution without an interpreter; where a shell is unavoidable, enforce allow-list validation and never concatenate user-influenced input into command strings.
• Build controller-class appliances into architecture as untrusted-pivot candidates: microsegment them, apply egress filtering, and require separate credentials/trust domains for the controller and the systems it manages.
• Deploy the process-creation detections above (Sigma → SIEM, auditd/eBPF telemetry into Wazuh/Splunk/Elastic) so that authenticated command injection produces an alert even absent a public PoC.
• Maintain an SBOM and asset inventory that identifies NVIDIA Infrastructure Controller for Linux deployments by version, so that the eventual affected-version list can be reconciled immediately rather than reconstructed under time pressure.
• Track CVE-2026-65130 for CISA KEV addition; if it is added, escalate to emergency change procedures given the S:C scope.

References

• NVD — CVE-2026-65130: https://nvd.nist.gov/vuln/detail/CVE-2026-65130
• CWE-78 — Improper Neutralization of Special Elements used in an OS Command: https://cwe.mitre.org/data/definitions/78.html
• MITRE ATT&CK T1190 — Exploit Public-Facing Application: https://attack.mitre.org/techniques/T1190/
• CISA Known Exploited Vulnerabilities Catalog (CVE-2026-65130 not currently listed; verify status): https://www.cisa.gov/known-exploited-vulnerabilities-catalog
• NVIDIA Product Security Incident Response (PSIRT) advisories portal — monitor for vendor advisory and fixed version: https://www.nvidia.com/en-us/security/

Exploit-in-the-wild status: No public PoC, no exploit code, no Nuclei template, and no CISA KEV listing were identified. No threat actor campaigns are known to be associated with CVE-2026-65130 at the time of writing. EPSS has not yet been scored by FIRST.org; no EPSS value is asserted here.