Nvidia's agent sandbox holds; the model server underneath it answers to any browser tab
Oasis Security says CVE-2026-65105 lets one malicious page reach the Ollama instance behind a NemoClaw agent and rewrite the template every prompt passes through.
The Product Desk
What happened
- Oasis Security disclosed CVE-2026-65105 in Nvidia's NemoClaw, triggerable by a single visit to a malicious website, after reporting it to Nvidia's PSIRT.
- NemoClaw starts the local Ollama server with OLLAMA_HOST=0.0.0.0:11434, putting the API on every interface while the install message still points at localhost.
- DNS rebinding gets past the remaining origin allowlist, so a page in the developer's browser can send requests to the local model server.
Why it matters
- constraint Isolation stops being the property that decides the outcome: a fence around the agent's file system and network says nothing about a service on the host that any browser tab can address.
- exposure The bind widens the target beyond the browser chain, so anyone sharing a network segment with the developer has the same unauthenticated route in.
- decision Teams that treated clearing a session or tightening guardrails as remediation now need a way to verify model definitions, since neither touches where the instruction lives.
- precedent Every local inference server that assumed loopback trust becomes fair game the moment an agent framework rebinds it for container access, and this is the template for the next report.
Ollama's API has no authentication. In place of it there are two middleware checks: an origin allowlist and validation of the Host header [5]. NemoClaw disables one of them by its own hand. The Host check is skipped whenever the bind address is not loopback [5], and NemoClaw starts Ollama with `OLLAMA_HOST=0.0.0.0:11434` [16]. That leaves the origin allowlist, which DNS rebinding walks around: a domain the attacker controls serves the victim a page on port 11434, then re-resolves to 127.0.0.1, and the browser raises no objection because same-origin policy keys on the hostname rather than the address behind it [6]. Two substitutes for authentication, one removed by configuration and one bypassed by a decade-old browser technique, come to zero controls in front of the API [15].
The reason NemoClaw binds that way is mundane. Docker containers have no route to 127.0.0.1, where Ollama binds by default [16], so the sandboxed agent needs the server on an interface it can see. The OpenShell sandbox fences off the file system, the network and the processes the agent can touch [3]; the model server it depends on sits outside that fence. Elad Luz, head of research at Oasis, said the blast radius of an AI system is its authorizations rather than its isolation [12]. Randolph Barr, CISO at Cequence Security, put it as plumbing: sandboxing the agent buys little if the thing it is built on is reachable from any tab [14].
The escalation from access to poisoning is the part worth reading twice. Injecting a hidden system prompt fails, because OpenClaw sends its own and overrides it [8]. So the researchers went below the prompt. Ollama's `/api/create` accepts a template field, a Go template that renders the message list into the raw text the model actually reads; an attacker pulls the existing template through `/api/show`, splices in an instruction and writes it back [9]. From then on every message passes through the attacker's version, including the agent's system prompt, which arrives at the model with the hidden instruction appended [10]. Oasis says an instruction in that position can tell the agent to write vulnerabilities that pass casual review, to keep quiet about security problems, or to push conversation contents to an outside endpoint [11].
Nothing about the model looks wrong afterwards. Name, size and metadata read as normal, and opening a fresh chat clears nothing, because the payload lives in the model definition rather than in conversation state an operator can reset [10]. The same access would also let an attacker delete models outright [7], which is loud. This is quiet. Oasis reported the flaw to Nvidia's PSIRT before publishing and released a video walking the chain from malicious website to a poisoned agent answering with the attacker's marker [2][13].
One detail deserves separate mention: with port 11434 live on every interface, other devices on the same network segment can reach it too, and the install message still reads `localhost:11434` [16]. An operator checking that line has no reason to think the server is anywhere but the loopback.
What to watch
- Whether Nvidia ships a fixed NemoClaw that reaches Ollama without binding 0.0.0.0, for example through a host gateway route.
- Whether Ollama enforces Host header validation on non-loopback binds or adds authentication to its API by default.
- Whether any tooling appears to verify model template integrity, given that name, size and metadata stay unchanged after poisoning.
Clarity's read
What the record supports and how the coverage leans. The claims behind it follow.
Reality
- Evidence52
- Adoption
- Insufficient
- Hype gap+18
- Incentives72
- Confidence48
Claim ledger
Ranked by verification strength, evidence, and original report placement.
- [1]
Researchers at nonhuman identity security company Oasis Security disclosed a vulnerability in Nvidia's NemoClaw that hands an attacker full control of the local model server powering a developer's AI agent.
- [2]
The vulnerability, tracked as CVE-2026-65105, can be triggered by one visit to a malicious website, and Oasis reported it to Nvidia's Product Security Incident Response Team before publishing.
- [3]
Nvidia released NemoClaw at its GTC conference in March as a safer way to run agents such as OpenClaw, with the agent inside an OpenShell sandbox that fences off the file system, the network and the processes it can touch.
- [4]
NemoClaw can run the agent's model locally through Ollama instead of calling a cloud service, and Ollama is the server an attacker ends up controlling.
- [5]
Ollama's API has no authentication; two middleware checks stand in for it, an origin allowlist and validation of the Host header, and the researchers found the Host check is skipped entirely whenever the bind address is not loopback.
- [6]
DNS rebinding defeats the origin check: the attacker points a domain at their own server, serves the victim a page on port 11434, then re-resolves the domain to 127.0.0.1; same-origin policy keys on the hostname rather than the address behind it, so requests from the page land on the victim's Ollama instance.
- [7]
Full API access alone lets an attacker enumerate what is installed, lift the machine's hostname and public key, or delete models outright.
- [8]
Injecting a hidden system prompt into the model does not survive contact with the agent, because OpenClaw sends its own system prompt and that overrides the one baked in.
- [9]
Ollama's /api/create endpoint accepts a template field whose value is a Go template that renders the message list into the raw text the model reads; an attacker can pull the model's existing template through /api/show, splice an instruction into it and write it back.
- [10]
Every message the client sends then passes through the attacker's template, including the agent's own system prompt, which reaches the model with the hidden instruction appended; name, size and metadata all read as normal, opening a fresh chat clears nothing, and the payload lives in the model definition below the conversation state an operator can reset.
- [11]
An instruction in that position can tell the agent to write vulnerabilities into code that passes casual review, to stay quiet about security problems, or to push conversation contents to an outside endpoint.
- [12]
Elad Luz, head of research at Oasis, said the change sits "one layer beneath anything a guardrail or an operator can see" and that the sandbox does not help much because the blast radius of an AI system is its authorizations rather than its isolation.
- [13]
A video published alongside the paper walks through the full chain, from malicious website to a poisoned agent answering with the attacker's marker.
- [14]
Randolph Barr, CISO at Cequence Security, said DNS rebinding has been a browser party trick for over a decade but pointing it at an unauthenticated local model server is the new part, that agentic AI risk lives in the plumbing rather than the model, and that sandboxing the agent does not buy much if the thing it is built on top of is reachable from any tab in the browser.
- [15]
Of the two middleware checks standing in for authentication on Ollama's API, NemoClaw's non-loopback bind disables the Host header check and DNS rebinding bypasses the origin allowlist, leaving zero effective controls in front of the API.
- [16]
Docker containers have no path to 127.0.0.1, where Ollama binds out of the box, so NemoClaw launches Ollama with the flag OLLAMA_HOST=0.0.0.0:11434; port 11434 goes live on every interface, other devices on the same network segment can hit it, and the install message still reads localhost:11434.
Get this ledger inside ChatGPT. Ask about any of our stories and the answer brings its figure, each claim’s verdict and the sources. Free, no account.
Sources
1 independent publisher whose own reporting we read for this story.
- siliconangle.comNvidia NemoClaw flaw let attackers poison the model behind a developer’s AI agent
1 article · August 25, 2026
Topics and entities
Follow any of these and your For You feed starts watching them — no settings page required.
Topics
- AI Agent SecurityFollow
- Vulnerability DisclosureFollow
- Local Model ServingFollow
- Model Integrity and PoisoningFollow
- DNS Rebinding and Browser-Mediated AttacksFollow