The TEE didn't protect what was running inside it
NEAR AI published a security incident report on November 9. An attacker used a remote code execution flaw in SGLang, the open-source inference engine running on NEAR AI's servers, to get code execution on one of those servers. From there the intrusion walked through the rest of the infrastructure.
The number people will circle is small — one line in the middle of the post. It is worth quoting in full.
"Confidential computing does not protect against a vulnerability in the software running inside the environment."
That is the compromised vendor saying out loud what the AI-infrastructure conversation has been talking around for two years. The TEE boundary is an integrity assertion about the artifact loaded into the enclave. It is not an assertion about what that artifact does once it runs.
What the attacker got
Per NEAR AI, on November 8 the attacker:
- Got code execution on one inference server through the SGLang RCE.
- Could have observed in-flight requests on that server, including requests the user had marked as confidential-mode and expected to be isolated inside the TEE.
- Pivoted to an internal system behind the previously deprecated Private Chat and downloaded account details for about 100 users — emails, names, and for some accounts plan and balance information.
- Reached 18 agents on a legacy NEAR AI Agents deployment that did not run inside the TEE, exposing chat history, settings, and logs.
- Recovered two NEAR AI Cloud customer API keys that had been written to logs on the inference server.
NEAR AI reports no indication that stored Private Chat conversations or uploaded files themselves were accessed. It has not published a CVE or affected SGLang versions, but says it reported the flaw to the SGLang project. The Cloud Security Alliance's CISO Daily Briefing for November 11 notes the same incident and that NEAR AI has not identified which flaw was used, out of the SGLang CVE cohort published this year.
Why the TEE sentence matters
Through 2025 and 2026 a quiet marketing pattern has grown up around AI inference: wrap the model in a trusted execution environment, attest the loaded weights, call the request confidential. The attestation story is real. The mistake is treating attestation as a containment story.
SGLang is a user-space Python program with a bytecode parser, a pickle loader, and a dozen other places a crafted input can reach eval. All of those live inside the enclave. An RCE in any of them runs where the enclave trusts its own code. Nothing about "the enclave is attested" prevents a parser bug from giving a request a shell.
Once that happens, the enclave stops helping. It cannot distinguish the inference engine's memory accesses from the attacker's memory accesses, because they are the same process. The confidential-mode request's plaintext is right there, next to the code the attacker now controls. So is the next request. So are, on NEAR AI's server, the API keys someone wrote to a log.
That is the sentence. The TEE did what it was built for — it protected the model and the request from the rest of the host. It did not and cannot protect the request from a bug in the software reading it.
The pattern this instance makes clear
Back it up and look at the week, not just the day:
- November 10: Microsoft Research publishes the Lazarus sleeper-neuron technique and writes that "trustworthy behavior during testing does not establish checkpoint integrity." That is an attestation-side failure — the artifact can pass every safety eval and still be subverted.
- November 9: NEAR AI writes that "confidential computing does not protect against a vulnerability in the software running inside the environment." That is the runtime-side failure — the software defending the artifact can be subverted while running.
Two different vendors, one business week apart, naming the complementary halves of the same gap. Neither evaluation of the artifact nor hardware isolation of the artifact is sufficient on its own. The thing that happens when the model is actually running — the live calls into the inference engine, the memory it touches, the files it writes, the keys those writes land in — is a separate trust surface that needs a separate control.
Three things to do this week
-
Treat your inference engine as your attack surface. SGLang is one name on a long list; vLLM, TGI, LiteLLM, and llama.cpp get pulled in with less review than a Node dependency. CERT/CC's VU#281278 and the broader SGLang CVE cohort — CVE-2026-5760, CVE-2026-15969 through CVE-2026-15978 — are the published tip of this iceberg. Pin versions. Watch the advisories. Patch on the clock a serious web framework gets.
-
Stop writing secrets to logs on inference servers. NEAR AI lost two live customer keys this way. The Apiiro Claude Code "Don't Ask Again" disclosure found 2,539 live secrets in public repos. The Fireworks AI breach exposed some customers' secrets and model weights from an inference provider's infrastructure. The AI tool-chain has a log-and-disk hygiene problem that pre-dates the AI parts; it is time to admit that and audit it like you'd audit a cash register.
-
Treat "we put it in a TEE" as a statement about the artifact, not the request. Ask, in writing: does your threat model account for an RCE in the software running inside the enclave? If the answer is "no, because the enclave," read NEAR AI's post and update the answer. The vendor that got hit says it does not.
Confidential computing is still useful. It was never going to be the whole story. On November 9 it got a short, clear line to that effect, from someone who was still writing the incident up.
SPR{K3 is a security research operation that pairs offensive vulnerability research with runtime behavioral defense. Defend is our runtime agent. To talk about a deployment, reach us at support@sprk3.com.