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).
4 steps from start to impact.
Identify an exposed NeMo Agent Toolkit MCP endpoint
/mcp or the SSE transport endpoint responds without a TLS or auth challenge.- 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
- 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
/mcp path returning MCP protocol handshake. No mainstream vulnerability scanner has a check yet (1 day post-disclosure).Enumerate available MCP tools and agent workflows
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.- Network connectivity to the MCP endpoint established in Step 1
- Tool catalogs vary widely by deployment — a dev sandbox may expose only a calculator demo; a production instance may expose dozens of enterprise connectors
tools/list calls; SIEM correlation on unexpected source IPs hitting port 9902.Invoke arbitrary tool calls for code execution or data exfiltration
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.- 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
- 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
nat / Python process; audit logs for database or API access from the NAT service account.Pivot to connected enterprise systems via agent tool credentials
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.- Connected tools have stored credentials accessible to the NAT runtime
- Downstream systems accept the extracted credentials without additional MFA or IP restrictions
- 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
.env files, YAML configs, or environment variable enumeration from the NAT process; downstream systems should alert on authentication from unexpected source IPs.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.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.- 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.
The supporting signals.
| In-the-wild exploitation | Not 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 availability | None 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 score | Not 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 breakdown | CVSS: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 versions | NeMo Agent Toolkit 1.0 through 1.8.0 (all releases prior to the fix). Installed via pip install nvidia-nat. |
| Fixed version | NeMo Agent Toolkit 1.9.0. Note: the toolkit is deprecated as of October 2026 — NVIDIA recommends migration to NeMo Relay, Helix, or Fabric. |
| Vendor advisory | NVIDIA Product Security GitHub: github.com/NVIDIA/product-security/tree/main/2026/5912. Prior NeMo Agent Toolkit bulletin: Security Bulletin November 2025. |
| Scanning / exposure data | No 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 timeline | CVE 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 lifecycle | NeMo 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.
- SecurityOnline — NVIDIA NeMo Agent Toolkit CVE-2026-65145 Scores CVSS 10.0
- OffSeq Radar — CVE-2026-65145 Missing Authentication Analysis
- Strix.ai — CVE-2026-65145 NeMo Agent Toolkit Missing Authentication
- ThreatInt — CVE-2026-65145 Record
- NVIDIA NeMo Agent Toolkit GitHub Repository
- NVIDIA Docs — NeMo Agent Toolkit FastMCP Server
- NVIDIA Docs — MCP Authentication for NeMo Agent Toolkit
- NVIDIA Product Security Advisory (GitHub)
Why this verdict
- Default localhost binding compresses exposure. The
nat mcp serveandnat fastmcp server runcommands bind to127.0.0.1by default. An operator must explicitly pass--host 0.0.0.0to 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.
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
#!/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