← Back to Feed CACHED · 2026-10-28 00:23:19 · CACHE_KEY CVE-2026-65145
CVE-2026-65145 · CWE-306 · Disclosed 2026-10-27

NVIDIA NeMo Agent Toolkit MCP server missing authentication for critical function

ASSESSED — NOISGATE
Vendor
—
—
—
Reassessed
—
—
—
Verdict: —
Do you agree?
01 · The Real Story

A front door with no lock — but the building is on a private road most attackers never find

CVE-2026-65145 is a missing authentication flaw (CWE-306) in the NVIDIA NeMo Agent Toolkit MCP/FastMCP server component, affecting versions 1.0 through 1.8.0. The toolkit is an open-source Python library (pip install nvidia-nat) used to orchestrate teams of AI agents via the Model Context Protocol (MCP). When deployed as a server (nat mcp serve or nat fastmcp server run), it listens on port 9902 by default. Prior to version 1.9.0, the nat mcp serve command started the server without built-in authentication — any network-reachable client could invoke agent workflows, execute arbitrary tool calls, read or tamper with data flowing through the agent pipeline, and achieve code execution on the host. The CVSS:3.1 vector AV:N/AC:L/PR:N/UI:N/S:C is technically accurate: zero auth, zero interaction, changed scope because a compromised agent toolkit pivots into every backend the agents can reach.

NVIDIA rated this a perfect 10.0 CRITICAL, and the vector math checks out — but the vendor score overestimates the blast radius for the median enterprise. Three real-world factors compress the effective severity. First, the server binds to localhost (127.0.0.1) by default; you must explicitly reconfigure --host 0.0.0.0 to expose it on the network, and NVIDIA's own docs warn against doing so without auth. Second, NeMo Agent Toolkit is a niche AI/ML developer framework, not a perimeter appliance or domain controller — the installed base is a fraction of a percent of enterprise hosts. Third, the toolkit was deprecated in October 2026 with EOL by year-end, meaning the addressable population is shrinking, not growing. None of this makes the bug harmless — when the server IS exposed on a reachable network segment with production MCP tools wired in, exploitation is trivial and the blast radius cascades through every connected API and data store — but the preconditions narrow the real-world threat surface enough to justify a downgrade to HIGH (8.5).

"CVSS 10 on paper, but default localhost binding and niche install base drop real-world risk to HIGH."
02 · The Attack Path

4 steps from start to impact.

STEP 01

Identify an exposed NeMo Agent Toolkit MCP endpoint

The attacker scans internal or external networks for TCP port 9902 (default FastMCP) or discovers the endpoint via service enumeration, internal documentation, or DNS records pointing to an AI agent server. The streamable-http transport at /mcp or the SSE transport endpoint responds without a TLS or auth challenge.
Conditions required:
  • NeMo Agent Toolkit server running version 1.0–1.8.0
  • Server bound to a non-localhost address (e.g. --host 0.0.0.0) without an authenticating reverse proxy
Where this breaks in practice:
  • Default bind address is localhost — only reachable from the same host unless explicitly reconfigured
  • NVIDIA docs emit a log-level warning when binding to non-localhost without auth, so attentive operators may catch this
  • The toolkit has a small installed base limited to AI/ML engineering teams
Detection/coverage: Port scan for 9902; HTTP probe for /mcp path returning MCP protocol handshake. No mainstream vulnerability scanner has a check yet (1 day post-disclosure).
STEP 02

Enumerate available MCP tools and agent workflows

With no authentication barrier, the attacker sends an MCP tools/list request to the server. The server responds with the full catalog of registered tool schemas, workflow names, and parameter definitions. This reveals which backends are wired in — databases, APIs, file systems, code interpreters, or external services.
Conditions required:
  • Network connectivity to the MCP endpoint established in Step 1
Where this breaks in practice:
  • Tool catalogs vary widely by deployment — a dev sandbox may expose only a calculator demo; a production instance may expose dozens of enterprise connectors
Detection/coverage: MCP server access logs (if enabled via NAT telemetry) will show unauthenticated tools/list calls; SIEM correlation on unexpected source IPs hitting port 9902.
STEP 03

Invoke arbitrary tool calls for code execution or data exfiltration

The attacker crafts MCP tools/call requests targeting the most dangerous available tools — typically a code execution tool, a file-system reader, or a database query tool. Because the server enforces no caller identity, every tool call executes with the service account's privileges (often the user who launched nat mcp serve). This yields remote code execution, arbitrary file read/write, or data exfiltration depending on what tools are connected.
Conditions required:
  • At least one MCP tool with dangerous capabilities (code exec, file I/O, DB access) is registered
  • The NAT process runs with sufficient OS-level privileges to perform the tool's action
Where this breaks in practice:
  • Impact scales with what tools are registered — a minimal deployment with only safe tools limits the blast radius
  • Many ML dev setups run as non-root user accounts, capping privilege escalation at user-level RCE
Detection/coverage: Host-based EDR should flag unexpected child processes spawned by the nat / Python process; audit logs for database or API access from the NAT service account.
STEP 04

Pivot to connected enterprise systems via agent tool credentials

MCP tools often carry embedded credentials — API keys in environment variables (e.g., NVIDIA_API_KEY), database connection strings, or OAuth tokens for SaaS integrations. The attacker extracts these from the runtime environment or tool configuration files (YAML workflows) and uses them to authenticate directly to downstream systems, bypassing the compromised toolkit entirely. The 'Changed Scope' in the CVSS vector reflects exactly this lateral pivot.
Conditions required:
  • Connected tools have stored credentials accessible to the NAT runtime
  • Downstream systems accept the extracted credentials without additional MFA or IP restrictions
Where this breaks in practice:
  • Well-segmented environments with credential vaulting (HashiCorp Vault, AWS Secrets Manager) and short-lived tokens limit the pivot radius
  • Network segmentation between the ML tier and production data stores adds another hop the attacker must clear
Detection/coverage: Credential access telemetry: monitor for reads of .env files, YAML configs, or environment variable enumeration from the NAT process; downstream systems should alert on authentication from unexpected source IPs.
03 · Compensating Control

1
HIGH 8.5→LOW 2.0
SEVERITY REDUCED
Rebind the server to localhost immediately — Verify every NeMo Agent Toolkit instance is bound to 127.0.0.1 (the default) and not 0.0.0.0 or a routable IP. Run ss -tlnp | grep 9902 on every host known to run NAT. If any instance is bound to a non-localhost address, change the --host flag to 127.0.0.1 and restart. This is a zero-downtime config change that eliminates remote exploitability entirely. Per the noisgate mitigation SLA for HIGH severity, deploy within 30 days — but given the trivial fix, do it this week.
2
HIGH 8.5→LOW 2.5
SEVERITY REDUCED
Place an authenticating reverse proxy in front of any network-exposed NAT instance — If the server MUST be network-accessible for multi-agent communication, deploy an authenticating reverse proxy (nginx + OAuth2-proxy, Envoy with JWT validation, or an API gateway with mTLS) in front of port 9902. This restores the missing authentication control at the network layer. Ensure the proxy terminates TLS and validates caller identity before forwarding to the NAT backend. Deploy within 30 days per the noisgate mitigation SLA.
3
HIGH 8.5→IGNORE 0.0
SEVERITY REDUCED
Upgrade to NeMo Agent Toolkit 1.9.0 — Version 1.9.0 patches CVE-2026-65145 directly. Run pip install --upgrade nvidia-nat==1.9.0 and restart all NAT processes. Verify with nat --version. Given the product's deprecation, also begin planning migration to NeMo Relay, Helix, or Fabric. Per the noisgate remediation SLA for HIGH severity, complete within 180 days — but prioritize sooner given the EOL timeline.
4
HIGH 8.5→MEDIUM 5.0
SEVERITY REDUCED
Network-segment the ML/AI tier from production data stores — Even after patching, ensure the network segment hosting NAT instances cannot directly reach production databases, identity stores, or sensitive APIs without traversing a firewall with explicit allow rules. This limits the Changed Scope blast radius for any future AI toolkit vulnerability. Deploy as part of ongoing network hygiene.
What doesn't work
  • WAF rules — NeMo Agent Toolkit uses the MCP protocol over HTTP streamable-http or SSE transport, not standard REST/GraphQL patterns. Generic WAF signatures won't inspect MCP tool invocation payloads or block unauthenticated MCP handshakes.
  • Host-based firewall blocking port 9902 inbound — this works as a network control but breaks legitimate multi-agent communication if the server is intentionally exposed for agent-to-agent workflows. It's equivalent to just rebinding to localhost with extra steps.
  • Upgrading Python or the OS — the vulnerability is in the application layer (NAT's missing auth check), not in the Python runtime, TLS stack, or operating system. OS-level patches don't help.
04 · Intelligence Metadata

The supporting signals.

In-the-wild exploitationNot observed. Not listed in CISA KEV. No campaigns or threat actor attribution documented as of 2026-10-28 (1 day post-disclosure).
Proof-of-concept availabilityNone public. No PoC repos found on GitHub, pocindex.io returns no results, no Nuclei templates, no ExploitDB or Metasploit modules. The trivial nature of the bug (send unauthenticated MCP requests) means a functional PoC is straightforward to write but none has been published.
EPSS scoreNot yet scored — CVE published 2026-10-27, EPSS data typically lags 1–3 days for new entries. Expect a moderate EPSS given CWE-306 base rate and network vector, but tempered by the niche product footprint.
CVSS vector breakdownCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H — perfect 10.0. Every metric at worst case. The Changed Scope is the decisive factor: compromise of the toolkit cascades to every backend the AI agents can reach.
Affected versionsNeMo Agent Toolkit 1.0 through 1.8.0 (all releases prior to the fix). Installed via pip install nvidia-nat.
Fixed versionNeMo Agent Toolkit 1.9.0. Note: the toolkit is deprecated as of October 2026 — NVIDIA recommends migration to NeMo Relay, Helix, or Fabric.
Vendor advisoryNVIDIA Product Security GitHub: github.com/NVIDIA/product-security/tree/main/2026/5912. Prior NeMo Agent Toolkit bulletin: Security Bulletin November 2025.
Scanning / exposure dataNo Shodan or GreyNoise tags for NeMo Agent Toolkit port 9902 as of 2026-10-28. The default localhost binding means internet-facing exposure is expected to be near zero. Internal network exposure depends on whether teams reconfigured --host 0.0.0.0.
Disclosure timelineCVE reserved 2026-07-21, published 2026-10-27. Credited to outside researchers (names not disclosed). Six vulnerabilities patched in the same NVIDIA update batch (including CVE-2026-65151, SQL injection, CVSS 8.4).
Product lifecycleNeMo Agent Toolkit deprecated October 2026, EOL by end of 2026. Successor products: NeMo Relay, Helix, Fabric. Organizations still running NAT should treat this as a final-patch-before-sunset scenario.

Sources.

  1. SecurityOnline — NVIDIA NeMo Agent Toolkit CVE-2026-65145 Scores CVSS 10.0
  2. OffSeq Radar — CVE-2026-65145 Missing Authentication Analysis
  3. Strix.ai — CVE-2026-65145 NeMo Agent Toolkit Missing Authentication
  4. ThreatInt — CVE-2026-65145 Record
  5. NVIDIA NeMo Agent Toolkit GitHub Repository
  6. NVIDIA Docs — NeMo Agent Toolkit FastMCP Server
  7. NVIDIA Docs — MCP Authentication for NeMo Agent Toolkit
  8. NVIDIA Product Security Advisory (GitHub)
05 · The Call

Final Verdict
↓ DOWNGRADED to HIGH (8.5/10)

Why this verdict

  • Default localhost binding compresses exposure. The nat mcp serve and nat fastmcp server run commands bind to 127.0.0.1 by default. An operator must explicitly pass --host 0.0.0.0 to make the server network-reachable. NVIDIA's docs log a warning when this is done without auth. This single default eliminates the 'any random internet scanner finds you' scenario and restricts the attack surface to the host itself or deliberate reconfigurations — a meaningful friction point that a CVSS 10.0 does not capture.
  • Niche installed base limits fleet-scale impact. NeMo Agent Toolkit is a Python library used by AI/ML engineering teams, not a ubiquitous infrastructure component. In an enterprise with 10,000 hosts, you might find NAT on 5–20 ML workstations or staging servers. Compare this to a Log4j (on thousands of Java services) or a Windows kernel CVE (on every host). The small denominator dramatically reduces the probability of any given attacker encountering this service.
  • No exploitation, no PoC, 1 day old. The vulnerability was published yesterday with no public proof-of-concept, no known exploitation, and no KEV listing. While the bug is trivially exploitable in concept (just send unauthenticated MCP requests), the absence of tooling and scanning activity means the immediate threat window is narrow.
  • Deprecated product, shrinking population. NVIDIA deprecated NeMo Agent Toolkit in October 2026 with EOL by year-end. The addressable install base is shrinking. Teams should be migrating off regardless of this CVE.
  • Role multiplier: AI agent orchestration tier. (a) *Low-value role — dev sandbox:* Most NAT installs are developer workstations running tutorial workflows (calculator demo, simple RAG). Blast radius is a single user's dev environment. (b) *Typical role — ML staging server:* NAT orchestrates agent workflows with test data. Compromise yields access to staging APIs and test databases — moderate impact, contained by environment segmentation. (c) *High-value role — production AI pipeline with enterprise MCP tools:* When NAT runs in production with tools wired to production databases, SaaS APIs, and code execution backends, the blast radius expands to every connected system. However, NeMo Agent Toolkit is NOT canonically a high-value-role component — it is not an IdP, hypervisor, backup system, or network edge device. Fewer than ~5% of installs are likely production-facing with high-value tool connections. This is sufficient to floor the verdict at HIGH (the chain succeeds and yields multi-system compromise) but not CRITICAL (the product itself is not infrastructure-defining and the default config is not exposed).

Why not higher?

A CRITICAL verdict would require either (a) the default configuration to be network-exposed without operator action, or (b) the product to be a canonical infrastructure component where ≥10% of installs occupy a high-value role by definition. Neither condition holds. The default localhost binding is a hard architectural friction point that requires deliberate misconfiguration to bypass, and the toolkit's installed base is dominated by development and prototyping use cases, not production infrastructure. The absence of any exploitation, PoC, or scanning activity further weakens the case for CRITICAL urgency.

Why not lower?

A MEDIUM verdict would undercount the impact when the preconditions ARE met. When a NeMo Agent Toolkit server IS bound to a reachable interface with production MCP tools, the attack is trivial (zero auth, zero interaction, low complexity) and the blast radius cascades through every connected backend — databases, APIs, code execution environments. The Changed Scope vector is earned and real. The CWE-306 class is consistently exploited in AI/ML tooling (see prior Jupyter, MLflow, Ray CVEs). Dismissing this as MEDIUM would leave production AI pipelines unpatched.

06 · Verification

Crowdsourced verification payload.

Run this script on each host suspected of running NeMo Agent Toolkit. It checks the installed nvidia-nat package version and whether any NAT server process is listening on a non-localhost address. Requires no special privileges (non-root is fine). Invoke: bash check_cve_2026_65145.sh

noisgate-verify.sh
BASHREAD-ONLYSAFE
#!/usr/bin/env bash
# check_cve_2026_65145.sh — Detect CVE-2026-65145 exposure
# Target: any host that may run NVIDIA NeMo Agent Toolkit
# Privileges: none (non-root)
# Output: VULNERABLE / PATCHED / UNKNOWN

set -euo pipefail

VULN_FOUND=0
PATCHED=0
UNKNOWN=0

# Step 1: Check if nvidia-nat is installed and get version
if command -v pip &>/dev/null; then
  NAT_VERSION=$(pip show nvidia-nat 2>/dev/null | grep -i '^Version:' | awk '{print $2}')
else
  NAT_VERSION=""
fi

if [ -z "$NAT_VERSION" ]; then
  # Also check pip3
  if command -v pip3 &>/dev/null; then
    NAT_VERSION=$(pip3 show nvidia-nat 2>/dev/null | grep -i '^Version:' | awk '{print $2}')
  fi
fi

if [ -z "$NAT_VERSION" ]; then
  echo "[INFO] nvidia-nat package not found via pip/pip3."
  # Check if nat binary exists anyway
  if ! command -v nat &>/dev/null; then
    echo "[INFO] 'nat' CLI not found in PATH."
    echo "UNKNOWN — NeMo Agent Toolkit does not appear to be installed on this host."
    exit 2
  else
    echo "[WARN] 'nat' CLI found but pip package version unknown."
    UNKNOWN=1
  fi
fi

if [ -n "$NAT_VERSION" ]; then
  echo "[INFO] nvidia-nat version installed: $NAT_VERSION"
  # Compare version — vulnerable: 1.0 through 1.8.x; fixed: 1.9.0+
  MAJOR=$(echo "$NAT_VERSION" | cut -d. -f1)
  MINOR=$(echo "$NAT_VERSION" | cut -d. -f2)
  if [ "$MAJOR" -eq 1 ] && [ "$MINOR" -le 8 ]; then
    echo "[VULN] nvidia-nat $NAT_VERSION is in the affected range (1.0–1.8.x)."
    VULN_FOUND=1
  elif [ "$MAJOR" -eq 1 ] && [ "$MINOR" -ge 9 ]; then
    echo "[OK] nvidia-nat $NAT_VERSION is patched (>=1.9.0)."
    PATCHED=1
  elif [ "$MAJOR" -ge 2 ]; then
    echo "[OK] nvidia-nat $NAT_VERSION is beyond the affected range."
    PATCHED=1
  else
    echo "[WARN] Could not parse version: $NAT_VERSION"
    UNKNOWN=1
  fi
fi

# Step 2: Check for running NAT server processes bound to non-localhost
echo ""
echo "[INFO] Checking for running NeMo Agent Toolkit server processes..."
if command -v ss &>/dev/null; then
  EXPOSED=$(ss -tlnp 2>/dev/null | grep ':9902' | grep -v '127.0.0.1' | grep -v '\[::1\]' || true)
  LOCALHOST_BOUND=$(ss -tlnp 2>/dev/null | grep ':9902' | grep -E '127.0.0.1|\[::1\]' || true)
  if [ -n "$EXPOSED" ]; then
    echo "[CRITICAL] NAT server port 9902 is bound to a non-localhost address!"
    echo "  $EXPOSED"
    echo "  This instance is network-reachable and exploitable if unpatched."
    VULN_FOUND=1
  elif [ -n "$LOCALHOST_BOUND" ]; then
    echo "[INFO] NAT server port 9902 is bound to localhost only (not network-exposed)."
  else
    echo "[INFO] No process listening on port 9902."
  fi
elif command -v netstat &>/dev/null; then
  EXPOSED=$(netstat -tlnp 2>/dev/null | grep ':9902' | grep -v '127.0.0.1' | grep -v '::1' || true)
  if [ -n "$EXPOSED" ]; then
    echo "[CRITICAL] NAT server port 9902 is bound to a non-localhost address!"
    echo "  $EXPOSED"
    VULN_FOUND=1
  else
    echo "[INFO] No non-localhost listener on port 9902 detected."
  fi
else
  echo "[WARN] Neither ss nor netstat available — cannot check listening sockets."
fi

# Step 3: Verdict
echo ""
if [ "$VULN_FOUND" -eq 1 ]; then
  echo "VULNERABLE — CVE-2026-65145: nvidia-nat is in the affected range and/or exposed on a network interface."
  exit 1
elif [ "$PATCHED" -eq 1 ]; then
  echo "PATCHED — nvidia-nat version is >= 1.9.0."
  exit 0
else
  echo "UNKNOWN — could not definitively determine vulnerability status."
  exit 2
fi