GPUStack operators should treat CVE-2026-102895 as a compromise-assessment event, not only an upgrade ticket. The vulnerability gives an unauthenticated remote request the built-in administrator identity when a vulnerable server incorrectly trusts loopback traffic or a client-controlled IP header. GPUStack says the flaw was exploited in the wild against a 2.1.1 deployment, where attackers created custom backends that launched reverse shells.
The project published its advisory on July 31, 2026. CISA added the vulnerability to the Known Exploited Vulnerabilities catalog on November 9 based on evidence of active exploitation and set November 12 as the federal remediation deadline. This is therefore a current response guide for a known-exploited issue, not a claim that the underlying bug was first disclosed today.
What CVE-2026-102895 changes in the trust model
GPUStack is an open-source platform for managing GPU clusters, model serving, workers, and provider integrations. Before version 2.2.0, the get_current_user function could promote a request to the built-in administrator account when the request source appeared to be 127.0.0.1 and force_auth_localhost was false, which was the default.
The vendor documents two practical paths to that trusted loopback state:
- Same-host reverse proxy: when Nginx or another gateway connects to GPUStack through
127.0.0.1, every remote client reaches the application through a loopback TCP peer. The application sees the proxy, not the original client. - Spoofed application header: a client-supplied
X-GPUStack-Real-IP: 127.0.0.1value can cause the request source to be treated as loopback when forwarding-header handling is unsafe.
The root cause is not simply a bad header. It is the use of network origin as an authentication decision. A reverse proxy legitimately changes the transport peer, while a request header is data that must be accepted only from a trusted gateway. Neither is proof of a user’s identity.
Why the impact reaches the GPU workers
The vendor assigns the issue CVSS 3.1 score 9.8 and lists GPUStack versions before 2.2.0 as affected. An unauthenticated attacker who reaches the administrative API may enumerate or modify users, models, workers, and configuration; create persistent administrator API keys with broad scope; and read worker credentials or cloud-provider secrets.
The advisory also identifies an administrative workflow, POST /v2/inference-backends/from-yaml, that can turn the control-plane bypass into code execution on worker hosts. That escalation makes the response scope wider than the web service. Defenders must examine the GPUStack server, connected workers, secrets accessible through the platform, and any cloud or registry accounts that may have been exposed.
Immediate containment and remediation
Preserve evidence before replacing the deployment
CISA’s KEV record requires forensic triage under BOD 26-04. If operationally safe, preserve the GPUStack database, application configuration, server and worker logs, reverse-proxy access and error logs, container metadata, current process listings, network connections, and the list of administrative users and API keys. Record collection times and cryptographic hashes for copied evidence.
Do not assume that a successful upgrade proves there was no earlier access. The vendor explicitly reports in-the-wild exploitation, and a malicious administrator key created before patching remains useful until it is revoked.
Reduce exposure while preparing the upgrade
- Remove the GPUStack API from direct internet exposure. Restrict it to an administrative VPN, trusted gateway, or tightly scoped source networks.
- On a vulnerable release that cannot be upgraded immediately, set
force_auth_localhost=trueso loopback requests require authentication. - At the edge, discard any client-supplied
X-GPUStack-Real-IPvalue. Accept identity-related forwarding data only from an authenticated, controlled gateway. - Review whether the application is reached through a same-host loopback upstream. Header stripping alone does not fix the vulnerable release’s trust in the TCP peer.
These controls reduce risk but do not replace the vendor fix. In 2.2.0, GPUStack removed the loopback auto-admin path and hardened client-IP handling. The old force_auth_localhost option is retained as a deprecated no-op because localhost callers must authenticate in fixed releases.
Upgrade the server before the workers
Upgrade to GPUStack 2.2.0 or a later stable release. GPUStack’s upgrade documentation says to upgrade the server first and then the workers. Preserve the deployment’s database, volumes, configuration, and startup arguments before recreating services.
For a Python package installation, first record the installed version:
python3 -m pip show gpustack | sed -n 's/^Version: /GPUStack /p'After testing the change in a staging environment, upgrade through the same package environment used by the service:
python3 -m pip install --upgrade 'gpustack>=2.2.0'
python3 -m pip show gpustack | grep '^Version:'Docker operators should pull a fixed, explicitly selected image tag and recreate the server with the same persistent volumes and arguments. Kubernetes deployments introduced with GPUStack 2.2.0 or later should follow the official Helm upgrade procedure and reuse the reviewed values file. Avoid replacing a pinned production deployment with an unreviewed development or release-candidate build.
Threat hunt after patching
Exact event names and log locations depend on the deployment, so the following are investigation objectives rather than universal indicators:
- Administrator accounts, role changes, or API keys that operators cannot attribute, especially broad-scope keys.
- Requests to
/v2/inference-backends/from-yamland newly created or modified inference backends. - Unexpected model, worker, cluster, provider, or configuration changes.
- Access-log requests carrying
X-GPUStack-Real-IP, especially a loopback value received from an untrusted source. - Shell processes, unusual child processes, new persistence, or outbound connections on GPU workers.
- Use of cloud-provider, registry, worker, model-repository, or other secrets accessible from the compromised control plane.
If unauthorized administrative access is plausible, revoke unknown keys and rotate all credentials that the compromised server could read. Do this after preserving the evidence needed to understand scope. Rebuild affected workers from known-good images when process or filesystem integrity cannot be established.
For additional containment planning, see our AI sandbox-escape response guide. Our shared-filesystem risk analysis for containerized AI workloads also explains why control-plane access can expand into worker and secret exposure.
Safe hands-on lab: audit the reverse-proxy boundary
This offline lab does not connect to GPUStack or send exploit requests. It uses a small heuristic scanner to identify Nginx rules that deserve immediate manual review.
Prerequisites and isolated setup
- Python 3.8 or later.
- Copies of the relevant Nginx configuration files, with secrets removed.
- A temporary working directory on an administrative workstation.
Create audit_gpustack_proxy.py:
#!/usr/bin/env python3
import re, sys
from pathlib import Path
loopback = re.compile(
r"proxy_pass\s+https?://(?:127\.0\.0\.1|localhost)(?::\d+)?", re.I
)
forwarded = re.compile(
r"proxy_set_header\s+X-GPUStack-Real-IP\s+(?![\"']{2}\s*;)([^;]+);", re.I
)
cleared = re.compile(
r"proxy_set_header\s+X-GPUStack-Real-IP\s+(?:[\"']{2}|\$null_value)\s*;", re.I
)
print("file,severity,finding")
for name in sys.argv[1:]:
text = Path(name).read_text(encoding="utf-8", errors="replace")
if loopback.search(text):
print(f"{name},HIGH,GPUStack upstream uses a loopback proxy target")
match = forwarded.search(text)
if match:
print(f"{name},CRITICAL,X-GPUStack-Real-IP is forwarded from {match.group(1).strip()}")
elif cleared.search(text):
print(f"{name},INFO,Client-supplied X-GPUStack-Real-IP is explicitly cleared")
else:
print(f"{name},MEDIUM,No explicit X-GPUStack-Real-IP clearing rule found")Create an intentionally unsafe sample:
location / {
proxy_pass http://127.0.0.1:30080;
proxy_set_header X-GPUStack-Real-IP $http_x_gpustack_real_ip;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}Create a hardened comparison sample:
location / {
proxy_pass http://gpustack_backend:30080;
proxy_set_header X-GPUStack-Real-IP "";
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}Run the audit:
python3 audit_gpustack_proxy.py unsafe-gpustack.conf hardened-gpustack.confExpected output:
file,severity,finding
unsafe-gpustack.conf,HIGH,GPUStack upstream uses a loopback proxy target
unsafe-gpustack.conf,CRITICAL,X-GPUStack-Real-IP is forwarded from $http_x_gpustack_real_ip
hardened-gpustack.conf,INFO,Client-supplied X-GPUStack-Real-IP is explicitly clearedInterpretation and troubleshooting
A finding is not proof of exploitation, and a clean result is not proof that the application is fixed. The scanner only matches common Nginx syntax. Included files, templates, ingress controllers, service meshes, and non-Nginx proxies require manual review. Validate the complete active configuration with nginx -T in an authorized maintenance context and confirm that the running GPUStack version is 2.2.0 or later.
If the output is empty, confirm that at least one readable configuration path was supplied. If variables or templates hide the upstream address, inspect their resolved values. When review is complete, move the findings into the incident record and delete sanitized lab copies from shared workstations:
rm -f audit_gpustack_proxy.py unsafe-gpustack.conf hardened-gpustack.confConclusion
CVE-2026-102895 turns an infrastructure convenience, trusting loopback traffic, into unauthenticated control of an AI serving platform. Because exploitation has been observed, defenders should preserve evidence, restrict exposure, upgrade to GPUStack 2.2.0 or later, revoke unauthorized keys, rotate exposed secrets, and examine every connected worker. The durable lesson is broader than one product: network location and proxy headers are context, not authentication.







