Nov 28, Paris: AI Health Hack #2 with Alan, Qovery and AWS. Applications close Nov 21

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.

Guillaume Da Silva
Staff Solutions Architect
NOV 21, 2026 · 19 MIN
GPUStack CVE-2026-102895 is on CISA's KEV list: the patch target, the forensic hunt and a hardening checklist for self-hosted inference

Key points:

  • 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.

Qovery · Infrastructure control plane
Build with Claude Code, Deploy with Qovery
Learn more

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:

DetailWhat the source saysSource
CVE IDCVE-2026-102895 (GitHub advisory GHSA-gj9m-f8ph-pmhr)GPUStack advisory
KEV date added2026-11-09CISA KEV feed
KEV due date2026-11-12CISA KEV feed
Required actionApply vendor mitigations under BOD 26-04 and its forensic triage requirements, or discontinue useCISA BOD 26-04
Ransomware use"Unknown"CISA KEV feed
Affected versionsAll GPUStack versions before 2.2.0NVD CVE-2026-102895
Fixed version2.2.0 (released 18 June 2026)GPUStack v2.2.0 release
CVSS9.8 Critical, AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, scored by GitHub as CNANVD CVE-2026-102895
WeaknessesCWE-287, CWE-290, CWE-346CISA KEV feed
ExploitationObserved in the wild against a 2.1.1 deployment, with attacker-created custom backends running reverse shellsGPUStack advisory

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.

Here is how the versions stack up against the 22 advisories in GPUStack's security advisory list at the time of writing:

Target versionFixes CVE-2026-102895 (KEV)Fixes CVE-2026-102894 (SAML bypass, 9.1)Advisories still open on that versionMy verdict
2.1.x or olderNoNoEverything, including the KEV entryTreat as compromised until proven otherwise
2.2.0 / 2.2.1YesNoSAML callback bypass and a high-severity missing-authorization issue (both fixed in 2.2.2), plus the 2.3.x fixesClears KEV only. Not a place to stay
2.2.2 / 2.2.3YesYes9 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.0YesYes10 advisories fixed in 2.3.1, including server-side code execution during model configuration evaluationUpgrade again
2.3.1YesYesNone published at the time of writingTarget

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:

  1. 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.
  2. 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.
  3. 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.

PriorityInstance profileFirst actionThen
1Internet-reachable, version below 2.2.0, reverse proxy on the same hostPull 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
2Internet-reachable, version below 2.2.0, no proxySame containment; the header forgery works directlySame as priority 1
3Internet-reachable, 2.2.0 to 2.2.3Restrict to VPN or private networkUpgrade to 2.3.1, check for SAML callback abuse below 2.2.2
4Private network only, any version below 2.3.1Set force_auth_localhost=true todayUpgrade in the next maintenance window, hunt if any shared network was compromised
5Already on 2.3.1Confirm the setting and the exposureKeep 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 lookWhat to search forWhy it matters
Reverse proxy and load balancer access logsRequests carrying an X-GPUStack-Real-IP header from outside; any request to /v2/ paths from IPs outside your admin rangeThe header forgery path leaves a trace at the edge if you log request headers
GPUStack server logsSuccessful API calls without an authentication header, POST /v2/inference-backends/from-yaml, API key creation, user creation or role changesThese are the admin actions the bypass opens up
GPUStack databaseAPI keys with scope *, admin users, custom inference backends, and their creation timestamps compared with your change recordsPersistence survives the upgrade
Worker hosts and podsShell processes spawned by inference backend processes, new outbound connections, unexpected containersThe in-the-wild exploitation used custom backends running reverse shells
Cloud audit logsActivity from the cloud identities GPUStack held: new instances, IAM changes, data readsStolen cloud credentials outlive the GPUStack fix
SAML endpoint (versions below 2.2.2)Requests to /auth/saml/callback, especially if you never configured SAMLCVE-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:

YAML
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-gateway-to-inference
  namespace: inference
spec:
  podSelector:
    matchLabels:
      app: vllm
  policyTypes: ["Ingress"]
  ingress:
    - from:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: gateway
      ports:
        - protocol: TCP
          port: 8000

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.

ControlStops 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.1YesNo, existing keys surviveOnly for new attemptsNoLow to medium
force_auth_localhost=true and header strippingYes, for this CVENoOnly for new attemptsNoLow
Management API on a private networkYes, from the internetLimits who can use stolen keysLimits who can reach the endpointNoMedium
Key, JWT and token rotationNoYesYes, for stolen sessionsYes, if cloud keys are includedMedium
Default-deny egress on worker podsNoNoBlocks reverse shells and exfiltrationPartlyMedium
Admission control (PSA, image allowlist)NoNoBlocks unknown images and privileged podsLimits node escapeMedium
Short-lived cloud identity (IRSA, Workload Identity) instead of stored keysNoNoNoYes, nothing long-lived to stealMedium 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
  • Hunt: keys with * scope, unknown admins, from-yaml backends, worker shells, outbound connections
  • 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 Da Silva
About the author
Guillaume Da Silva

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.