GPUStack CVE-2026-102895 is on CISA's KEV list: the patch target, the forensic hunt and a hardening checklist for self-hosted inference
CISA added GPUStack CVE-2026-102895 to the KEV catalog on 9 November 2026 with a 12 November due date. Here is the version to patch to, how to find every exposed GPUStack server, what to rotate, which logs show exploitation, and how to harden vLLM and NIM endpoints on Kubernetes GPU clusters.
CVE-2026-102895 is an unauthenticated admin bypass in GPUStack before 2.2.0. A request that looks like it comes from 127.0.0.1 (through a same-host reverse proxy, or a forged X-GPUStack-Real-IP header) becomes the built-in administrator. CISA added it to KEV on 9 November 2026 with a due date of 12 November 2026 and a forensic triage flag.
2.2.0 clears the KEV entry, but I would not stop there. The companion SAML bypass (CVE-2026-102894, 9.1) is fixed only in 2.2.2, and GPUStack published 19 more advisories fixed in 2.3.0 and 2.3.1. As of 21 November 2026, upgrade to 2.3.1.
Patching does not evict an attacker. Anyone who reached a vulnerable server could mint a persistent admin API key with scope *, read worker and cloud credentials, and run code through POST /v2/inference-backends/from-yaml. Hunt, rotate, then reopen.
No management API on the internet. Expose only the inference paths through a gateway that strips client-supplied IP headers, keep the UI and /v2 admin API on a private network, and block egress from GPU worker pods by default.
The same rules apply to vLLM and NIM endpoints. vLLM's --api-key covers only some path prefixes, and its multi-node traffic is insecure by default. NetworkPolicies and admission control do the rest.
I spent the week after 9 November on calls with teams who run their own inference. Most of them knew GPUStack was in their stack. Fewer knew which version, and almost nobody knew whether the management port was reachable from outside. That gap is what turns a KEV entry into an incident.
This is the runbook I walked them through. It covers GPUStack specifically, then the hardening that applies to any self-hosted inference server on Kubernetes GPU nodes. If you also run NVIDIA NIM, the upgrade mechanics (digest pinning, cache warm-up, canary on one GPU pool) are in my NIM security upgrade runbook, so I won't repeat them here.
What exactly did CISA add to the KEV catalog on 9 November 2026?
CISA added CVE-2026-102895, "GPUStack Improper Authentication Vulnerability", to the Known Exploited Vulnerabilities catalog on 9 November 2026, with a remediation due date of 12 November 2026. That is a three-day window, and the entry is marked forensicTriage: Yes, so federal agencies must look for compromise as well as patch (CISA KEV catalog JSON feed).
I checked every detail in the prompt that brought you here against the primary sources. They match:
The 9.8 score on NVD comes from GitHub as the CNA (NVD lists it as "Secondary" and has not published its own score). And the timeline is long: the fix shipped in 2.2.0 on 18 June, GitHub published the advisory on 31 July, NVD published the CVE on 4 November, and CISA listed it five days later. Anyone on a release from before June has been exposed for months, with the details public since July.
The bug itself is short. Before 2.2.0, get_current_user in gpustack/api/auth.py treated any request from a loopback source as the built-in administrator when force_auth_localhost was false, and false was the default (NVD). Put nginx on the same host with proxy_pass http://127.0.0.1:<port> and every remote request arrives from 127.0.0.1. Or skip the proxy and send X-GPUStack-Real-IP: 127.0.0.1.
Which GPUStack version is safe to patch to?
Patch to GPUStack 2.3.1, the latest stable release as of 21 November 2026 (GPUStack releases). Version 2.2.0 removes the loopback auto-admin path and satisfies the KEV entry, but it leaves other critical issues open that an attacker on your network can chain.
SAML callback bypass and a high-severity missing-authorization issue (both fixed in 2.2.2), plus the 2.3.x fixes
Clears KEV only. Not a place to stay
2.2.2 / 2.2.3
Yes
Yes
9 advisories fixed in 2.3.0 (7 high) and 10 fixed in 2.3.1 (2 critical, 3 high)
Acceptable as a same-day stopgap if a 2.3.x jump is risky
2.3.0
Yes
Yes
10 advisories fixed in 2.3.1, including server-side code execution during model configuration evaluation
Upgrade again
2.3.1
Yes
Yes
None published at the time of writing
Target
The SAML issue deserves its own line. From 0.7.1 until 2.2.2, /auth/saml/callback minted a session without verifying the SAML response signature, "even when SAML was not configured" (NVD CVE-2026-102894). It is not on the KEV list, and CISA's own SSVC record marks its exploitation as "none" today. It is still a second, unauthenticated way to become admin on any version below 2.2.2.
The 2.3.x advisories matter most if you run GPUStack multi-tenant. Several are cross-tenant: a cluster read endpoint that discloses huggingface_token and registry passwords to any authenticated user (GHSA-7345-vjfr-2hcx), organization members bypassing Kubernetes API proxy restrictions (GHSA-mv55-58pg-4xgf), and a world-readable jwt_secret_key under /var/lib/gpustack that lets a local user forge admin JWTs (GHSA-72j3-6rmw-742x).
If you cannot upgrade in the next hour, apply the vendor workarounds from the advisory right now: set force_auth_localhost=true (CLI flag --force-auth-localhost), make sure your proxy cannot make external traffic look like loopback, strip any client-supplied X-GPUStack-Real-IP header at the edge, and restrict API access to trusted networks (GPUStack advisory). These stop new exploitation of this one CVE. They do nothing about an attacker who already holds an admin key.
Step 1: How do I find every GPUStack server we run, and which ones are exposed?
Start with an inventory of every GPUStack server, its version, and every network path that reaches its port. GPUStack starts with one docker run on a spare GPU box, so expect more instances than you think. The Cloud Security Alliance note counted more than 940,000 Docker Hub pulls of the image, while pointing out that this is a usage signal, not a count of exposed servers.
On Kubernetes, list every pod running a GPUStack image across all clusters:
BASH
kubectl get pods -A -o jsonpath='{range .items[*]}{.metadata.namespace}{"\t"}{.metadata.name}{"\t"}{range .spec.containers[*]}{.image}{" "}{end}{"\n"}{end}' | grep -i gpustack
On plain Docker hosts and GPU VMs:
BASH
docker ps --format '{{.ID}}\t{{.Image}}\t{{.Ports}}' | grep -i gpustack
gpustack version # on bare-metal or pip installs
Then map exposure for each instance. Three questions decide the priority:
Does any path from the internet reach the server port? Check Kubernetes Services of type LoadBalancer or NodePort, Ingress and Gateway routes, cloud security groups or firewall rules, and any public IP on the GPU VM.
Is there a reverse proxy on the same host or in the same pod? That is the exact configuration where every request arrives as 127.0.0.1, header or no header.
What did this instance hold? Cloud provider credentials, Hugging Face tokens, registry passwords and worker registration tokens all widen the blast radius.
For Kubernetes, this one-liner lists every externally reachable Service so you can match it against the GPUStack namespaces:
BASH
kubectl get svc -A -o wide | grep -E 'LoadBalancer|NodePort'
Write the result down as a table: instance, version, exposure (internet, VPN, cluster-only), proxy in front (yes or no), credentials held. That table decides your order in Step 2.
Step 2: In what order should we patch, contain and hunt?
Contain internet-exposed instances first, then patch, then hunt, and only reopen access after the hunt and the rotation are done. An exposed pre-2.2.0 server with a same-host proxy has been exploitable without a header trick for months, so treat it as a possible compromise from the start.
Priority
Instance profile
First action
Then
1
Internet-reachable, version below 2.2.0, reverse proxy on the same host
Pull it off the internet now (remove the public route or security group rule)
Snapshot disks and logs for forensics, upgrade to 2.3.1, hunt, rotate everything it held
2
Internet-reachable, version below 2.2.0, no proxy
Same containment; the header forgery works directly
Same as priority 1
3
Internet-reachable, 2.2.0 to 2.2.3
Restrict to VPN or private network
Upgrade to 2.3.1, check for SAML callback abuse below 2.2.2
4
Private network only, any version below 2.3.1
Set force_auth_localhost=true today
Upgrade in the next maintenance window, hunt if any shared network was compromised
5
Already on 2.3.1
Confirm the setting and the exposure
Keep it on the patch watch list
Take the snapshot before you upgrade. An upgrade restarts processes and can rotate logs, and the evidence BOD 26-04's forensic triage asks for lives on the box you are about to change.
For the upgrade itself on Kubernetes, GPUStack has shipped a Helm chart since 2.2.0 and added a Helm upgrade guide in 2.2.2 (v2.2.2 release notes). Back up the GPUStack database first, upgrade the server, then the workers, and pin the image by digest so the version you validated is the one that runs.
Step 3: Which credentials do we rotate after CVE-2026-102895?
Rotate every credential GPUStack held or issued on any instance that was reachable while vulnerable. The advisory lists what an attacker could do with admin access: create persistent admin API keys with scope ["*"], enumerate and change users, models, workers and configuration, read worker credentials and cloud provider secrets, and execute code through the admin-only POST /v2/inference-backends/from-yaml endpoint (GPUStack advisory).
Here is the rotation list I use:
GPUStack API keys. Delete every key you cannot tie to a known owner, with particular attention to keys carrying the * scope. Then reissue the legitimate ones.
Admin accounts and passwords. Remove unknown admin users, and change initial_admin_password if it is still valid.
JWT signing key. Rotate the server's jwt_secret_key. GPUStack's own guidance notes that "JWT key rotation invalidates sessions signed with the old key" (GHSA-72j3-6rmw-742x), which is exactly what you want after a possible compromise.
Worker and registration tokens. Revoke and replace them, then re-register workers you trust.
Cloud provider credentials. Any AWS, GCP, Azure or other cloud credential stored in GPUStack for GPU instance provisioning. Rotate the key, and review the cloud audit trail (CloudTrail, Cloud Audit Logs, Azure Activity Log) for what that identity did since the server became reachable.
Model and registry secrets. Hugging Face tokens, private registry passwords and any model provider API keys stored in GPUStack.
Anything mounted into worker containers. Secrets in environment variables or volumes are readable from a reverse shell on the worker.
Rotate after the upgrade, not before. Rotating on a still-vulnerable server just hands the attacker the new keys.
Step 4: Which logs show that a GPUStack server was exploited?
Look for successful admin actions without a matching authenticated session, new API keys and backends nobody created, and shells or outbound connections from worker processes. The vendor advisory and the CSA research note point to the same four areas.
Where to look
What to search for
Why it matters
Reverse proxy and load balancer access logs
Requests carrying an X-GPUStack-Real-IP header from outside; any request to /v2/ paths from IPs outside your admin range
The header forgery path leaves a trace at the edge if you log request headers
GPUStack server logs
Successful API calls without an authentication header, POST /v2/inference-backends/from-yaml, API key creation, user creation or role changes
These are the admin actions the bypass opens up
GPUStack database
API keys with scope *, admin users, custom inference backends, and their creation timestamps compared with your change records
Persistence survives the upgrade
Worker hosts and pods
Shell processes spawned by inference backend processes, new outbound connections, unexpected containers
The in-the-wild exploitation used custom backends running reverse shells
Cloud audit logs
Activity from the cloud identities GPUStack held: new instances, IAM changes, data reads
Stolen cloud credentials outlive the GPUStack fix
SAML endpoint (versions below 2.2.2)
Requests to /auth/saml/callback, especially if you never configured SAML
CVE-2026-102894 worked even without SAML configured
On Kubernetes, the API server audit log helps too. A compromised GPUStack server that manages a Kubernetes cluster acts through its own ServiceAccount, so filter the audit log on that identity and look for pods, Secrets reads or RoleBindings created since the server became reachable. If you have runtime detection (Falco, Tetragon or a cloud equivalent), the "shell spawned in container" rule is the one that fires for this attack.
If the server sat behind a same-host proxy on a version before 2.2.0, it has been exploitable since it was deployed. Hunt back to the earliest log you have, and if that does not cover the exposure period, say so in the incident record and rotate anyway.
Step 5: How do we keep the management API off the public internet?
Expose only the inference paths through a gateway, and keep the GPUStack UI and the /v2 management API on a private network reachable only from a VPN or an admin network. With that design, CVE-2026-102895 is reachable only from inside your network.
In practice that means four rules:
The GPUStack Service stays ClusterIP. No LoadBalancer, no NodePort, no public IP on the GPU VM. Admins reach the UI through a VPN, a bastion or kubectl port-forward.
A gateway in front of inference allowlists paths. Route only the OpenAI-compatible inference paths your applications call. Everything else returns 404 at the gateway.
The gateway owns client identity. Strip X-GPUStack-Real-IP, X-Forwarded-For and X-Real-IP from incoming requests, then set them yourself from the real peer address.
Never put the proxy on loopback in front of an unpatched server. If the proxy must run on the same host, upgrade first and set force_auth_localhost=true anyway.
We saw the same thing when ingress-nginx hit end of maintenance: the cheapest containment for its new CVE was to shrink who could reach the controller (our ingress-nginx runbook).
Run your inference stack in your own cloud, with the controls on.
Qovery deploys GPUStack, vLLM or NIM on Kubernetes in your own AWS, GCP, Azure or Scaleway account, with GPU node pools per service, RBAC and audit logs on every change.
Step 6: How should authentication work in front of inference endpoints?
Every inference endpoint needs authentication enforced by a component you control, and admin access needs a separate, stronger path. The GPUStack bug was a flaw in built-in auth, so never let one server's built-in auth be the only layer.
A layered setup I recommend:
Users and admins sign in through your identity provider (OIDC) at the gateway or an auth proxy, with MFA for admin roles.
Applications call inference with per-application API keys or workload identity, never a shared key pasted into five services.
The inference server's own keys (GPUStack API keys, vLLM --api-key) stay on as a second layer. Treat them as defense in depth.
SAML and SSO callbacks are disabled if you do not use them, and upgraded if you do. CVE-2026-102894 shows why.
For vLLM specifically, read the scope of --api-key carefully. The vLLM security guide says it provides authentication "only for endpoints under the /v1, /v2, /inference, and /cohere path prefixes", and warns that "the /invocations endpoint is particularly concerning as it provides unauthenticated access to the same inference capabilities as the protected /v1 endpoints." The same guide recommends deploying vLLM "behind a reverse proxy" that "explicitly allowlists only the endpoints you want to expose." That is the gateway rule from Step 5 again.
How do we harden vLLM and NIM inference servers on Kubernetes GPU nodes?
Harden inference servers with four Kubernetes controls: default-deny NetworkPolicies, egress restrictions on GPU worker pods, admission policies that block risky pod specs, and images pinned by digest from your own registry. These controls limit what an attacker can do even after they get admin on an inference manager like GPUStack.
Network policies: default deny, then allow the gateway
Start every inference namespace with a default-deny ingress policy, then allow traffic only from the gateway namespace to the serving port:
NetworkPolicies need a CNI that enforces them (Cilium, Calico, or the VPC CNI's network policy agent on EKS). Check that yours does before you rely on one.
For multi-node vLLM, isolate the inter-node traffic too. The vLLM guide states that "all communications between nodes in a multi-node vLLM deployment are insecure by default" and that torch.distributed "should be considered insecure by default" (vLLM security guide). Allow those ports only between the pods of the same deployment.
Egress: stop the reverse shell
The in-the-wild GPUStack exploitation ran reverse shells from attacker-created backends. A default-deny egress policy on GPU worker pods stops that callback. Model downloads still need to reach Hugging Face or your model mirror, so allow egress only to that mirror, your registry and DNS, ideally through an egress proxy with an allowlist. Teams that pre-load weights onto a volume or an object store in the same cloud account can close egress almost completely.
Admission control: decide what a hijacked controller can schedule
GPUStack, KubeRay and similar managers create pods on your behalf. If an attacker controls the manager, admission control decides what they can launch. Enforce at least:
Pod Security Admission baseline, ideally restricted, on inference namespaces. GPU access goes through the NVIDIA device plugin, so serving pods rarely need privileged, hostNetwork, hostPID or hostPath (Pod Security Standards).
Images only from your registry, pinned by digest, enforced with Kyverno or a ValidatingAdmissionPolicy. An attacker-supplied backend image fails admission.
No LoadBalancer or NodePort Services in inference namespaces without an explicit exception, so nobody re-exposes the management API by accident during an incident.
A tightly scoped ServiceAccount for the manager, limited to its own namespaces, with no rights on Secrets elsewhere and no RoleBinding creation.
Images and upgrades
Scan inference images (vLLM, SGLang, NIM, GPUStack) on every new tag, pin digests, and canary upgrades on one GPU node pool. My NIM upgrade runbook covers the full sequence, and the vLLM CUDA 13 migration checklist covers driver compatibility for vLLM upgrades.
Which control stops which part of this attack?
Each layer stops a different step of the GPUStack attack chain documented in the advisory, so one layer on its own leaves you exposed.
Control
Stops initial access (CVE-2026-102895)
Stops persistence (admin API keys)
Stops code execution (from-yaml backends)
Stops lateral movement (stolen cloud credentials)
Effort
Upgrade to 2.3.1
Yes
No, existing keys survive
Only for new attempts
No
Low to medium
force_auth_localhost=true and header stripping
Yes, for this CVE
No
Only for new attempts
No
Low
Management API on a private network
Yes, from the internet
Limits who can use stolen keys
Limits who can reach the endpoint
No
Medium
Key, JWT and token rotation
No
Yes
Yes, for stolen sessions
Yes, if cloud keys are included
Medium
Default-deny egress on worker pods
No
No
Blocks reverse shells and exfiltration
Partly
Medium
Admission control (PSA, image allowlist)
No
No
Blocks unknown images and privileged pods
Limits node escape
Medium
Short-lived cloud identity (IRSA, Workload Identity) instead of stored keys
No
No
No
Yes, nothing long-lived to steal
Medium to high
GPUStack stores cloud provider credentials so it can provision GPU instances. Wherever you can, replace stored static keys with workload identity bound to the pod (IAM Roles for Service Accounts on EKS, Workload Identity on GKE and AKS), so a database dump does not contain a usable cloud key.
What does the full patch and hardening checklist look like?
Copy this into your incident ticket.
CVE-2026-102895 response
Inventory every GPUStack instance: version, exposure, proxy in front, credentials held
Remove internet routes to any instance below 2.2.0
Snapshot disks, database and logs before changing anything
Set force_auth_localhost=true and strip X-GPUStack-Real-IP at the edge
Upgrade to 2.3.1 (2.2.2 at minimum as a stopgap), pinned by digest
Rotate API keys, admin passwords, jwt_secret_key, worker and registration tokens, cloud and model credentials
Review cloud audit logs for the identities GPUStack held
Reopen access only through the gateway, after hunt and rotation
Baseline for vLLM, NIM, SGLang and GPUStack on Kubernetes
Management APIs and UIs on a private network only
Gateway with a path allowlist and OIDC in front of inference
Default-deny ingress and egress NetworkPolicies per inference namespace
Pod Security Admission baseline or restricted on inference namespaces
Image allowlist and digest pinning enforced at admission
Workload identity instead of stored cloud keys
Every inference image on a patch watch list with an owner
For more guides like this one, our infrastructure security hub groups the CVE runbooks and hardening checklists in one place.
Where does Qovery fit in a runbook like this?
Qovery does not patch GPUStack for you, and it does not replace a forensic hunt. It takes care of the platform plumbing around the inference server so that the safe setup is the default one. Qovery is an Agentic DevOps platform: it deploys and operates apps on Kubernetes in your own AWS, GCP, Azure or Scaleway account, or on a Kubernetes cluster you already run. Qovery never hosts your workloads, so your GPUs, model weights and logs stay in your account.
For a GPUStack, vLLM or NIM deployment:
Version changes are deployments. You run GPUStack as a Helm service or vLLM and NIM as container services, and bumping a version or a digest goes through a deployment with history, so rolling back is a redeploy of the previous version.
Staging before production. Clone the production environment, upgrade the clone to 2.3.1, test it, then promote.
GPU node pools per service on Qovery-managed clusters on any cloud, and Karpenter on AWS, so a canary on one pool is a configuration change.
RBAC and audit logs. Every change to a service (who exposed a port, who changed an image tag) lands in the Qovery audit log, which is the record you want during an incident review.
The NetworkPolicies, admission policies, gateway rules and the hunt stay with your team.
How do I check this from Claude Code or Cursor with Qovery?
If your inference services already run on Qovery, your coding agent can do the inventory and the upgrade prep through the Qovery Agent Skills and the MCP Server. Start read-only.
BASH|1. Qovery Agent Skills, one install for Claude Code, Cursor, Codex, OpenCode, Gemini CLI
curl -fsSL https://skill.qovery.com/install.sh | bash
# 2. MCP Server for Claude Code over OAuth, read-only by default
claude mcp add --transport http qovery https://mcp.qovery.com/mcp --callback-port 4242
The first command installs the skills; your agent asks you to approve it before it runs. The second connects the MCP Server and opens an OAuth login in your browser, and it stays read-only unless you add write access explicitly.
Then ask in plain language: "list every service in my Qovery organization running a gpustack, vllm or nim image, with its image tag and whether it has a public port". For the fix, ask the agent to clone the environment and propose the upgrade to 2.3.1 there first. You review the plan before anything changes. The AI agent quickstart and the Claude Code integration page cover the setup.
Frequently asked questions
What is GPUStack CVE-2026-102895?
CVE-2026-102895 is an authentication bypass in GPUStack before 2.2.0. When force_auth_localhost was false (the default), any request that appeared to come from 127.0.0.1, through a same-host reverse proxy or a forged X-GPUStack-Real-IP header, was treated as the built-in administrator. GitHub, as CNA, scored it 9.8 Critical, and exploitation was observed in the wild against a 2.1.1 deployment.
When was CVE-2026-102895 added to CISA's KEV catalog, and what is the due date?
CISA added CVE-2026-102895 to the Known Exploited Vulnerabilities catalog on 9 November 2026, with a remediation due date of 12 November 2026. The entry carries a forensic triage requirement under BOD 26-04, so agencies must check for compromise as well as patch. Ransomware use is listed as unknown.
What is the safe patch and hardening checklist for teams self-hosting AI inference on GPU clusters?
Upgrade GPUStack to 2.3.1 (2.2.0 is the minimum that fixes the KEV entry, 2.2.2 also fixes the SAML bypass), after snapshotting logs for forensics. Then hunt for admin API keys with * scope and backends created through from-yaml, rotate every key and token GPUStack held, and keep the management API on a private network behind a gateway that strips client IP headers. As a baseline, add default-deny NetworkPolicies, egress restrictions on GPU worker pods, Pod Security Admission and an image allowlist on every inference namespace.
Is upgrading to GPUStack 2.2.0 enough?
Version 2.2.0 fixes CVE-2026-102895 and satisfies the KEV entry, but it leaves CVE-2026-102894 open, a 9.1 SAML callback bypass fixed only in 2.2.2. GPUStack also published 19 further advisories fixed in 2.3.0 and 2.3.1, including two critical ones in 2.3.1. Target 2.3.1, and use 2.2.2 only as a short-term stopgap.
Do I need to rotate credentials if I patched GPUStack quickly?
Yes, if the server was reachable by anyone untrusted while it ran a vulnerable version. An attacker with admin access could create persistent API keys and read worker and cloud provider credentials, and none of that is undone by an upgrade. Rotate after upgrading, so the new credentials never sit on a vulnerable server.
Does vLLM's --api-key flag protect every endpoint?
No. The vLLM security guide says --api-key covers only endpoints under the /v1, /v2, /inference and /cohere prefixes, and calls out /invocations as unauthenticated access to the same inference capabilities. Put vLLM behind a gateway that allowlists the paths you need and enforces its own authentication.
Guillaume is a Staff Solutions Architect at Qovery. He helps customers troubleshoot production infrastructure and writes about Kubernetes operations, AI agents, and reliable cloud platforms.
Next step
Run your inference stack in your own cloud, with the controls on.
Qovery deploys GPUStack, vLLM or NIM on Kubernetes in your own AWS, GCP, Azure or Scaleway account, with GPU node pools per service, RBAC and audit logs on every change.