/

CVE-2026-58658

Severity:

HIGH RISK

(8.2)

Missing Authentication (CWE-306) in GPUStack Worker APIs

CVE-2026-58658

Deferred

Vulnerability type

Category:

Missing Authentication

CWE:

CWE-306

Impact:

Sensitive Information Disclosure and Configuration Tampering

Severity:

HIGH RISK

(8.2)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

GPUStack up to version 2.2.1 exposes worker debugging and logging endpoints without any authentication controls, allowing unauthenticated access to sensitive operational data.

An attacker who can reach the worker port can stream inference logs containing prompts and completions, enumerate model instances, and alter logging behavior, turning routine observability surfaces into a data exposure and configuration tampering risk.

Affected context

This vulnerability arises in GPUStack deployments where worker ports are reachable from untrusted networks (such as shared clusters, multi-tenant environments, or misconfigured internal services).

The risk is most pronounced when the /serveLogs and /debug endpoints are enabled by default, exposed via ingress or load balancers, and used to collect inference logs, prompts, completions, and profiling data without authentication or access control.

Exploit preconditions

  • Attack surface: HTTP endpoints /serveLogs and /debug exposed on the GPUStack worker port.
  • Required access: Network-level ability to connect to the worker port from the attacker's environment (no credentials required).
  • Trigger point: Direct HTTP requests to the logging and debug endpoints, including enumeration of model instance IDs.
  • Why exploitation is possible: The endpoints lack authentication and authorization checks, so any caller can retrieve inference logs, profiling data, and modify logging configuration.

Why this happens

The underlying bug class is missing authentication on sensitive service endpoints, aligning with CWE-306: Missing Authentication for Critical Function.

In GPUStack workers, observability and debug routes were implemented under the assumption of trusted access, leaving them open on the same port as serving traffic with no authentication or role checks.

This design pattern treats operational APIs as implicitly safe, but when they carry user prompts, completions, and configuration controls, the absence of authentication turns them into a broad information disclosure and configuration tampering vector.

Potential impact

  • Unauthenticated streaming of inference logs containing user prompts and model completions.
  • Exposure of potentially sensitive or proprietary model usage data and tenant identifiers.
  • Unauthorized modification of log levels and worker debug configuration.
  • Insight into memory profiling and performance data that could aid further targeted attacks.
  • Increased attack surface for social engineering or data exfiltration campaigns based on observed prompts and outputs.

General mitigation guidance

Mitigation typically focuses on enforcing strict access control around operational endpoints and minimizing exposed debug surfaces.

Common defensive patterns include:

  • Treating all logging and debug APIs as sensitive, requiring authentication and role-based authorization.
  • Separating public serving interfaces from administrative and observability interfaces, preferably on distinct ports or networks.
  • Applying default-deny policies for debug and profiling endpoints, enabling them only for trusted operators and environments.
  • Minimizing retention and granularity of inference logs, especially where prompts and completions may contain personal or proprietary data.
  • Using network segmentation, service meshes, or API gateways to enforce authentication and limit reachability of worker management endpoints.

How teams detect issues like this

Detection typically combines configuration review with runtime monitoring:

  • Static analysis or configuration linting to identify routes or handlers that lack authentication and authorization middleware.
  • Code review practices that flag any new administrative, logging, or debug endpoints exposed on serving ports without explicit access control.
  • Security policies in API gateways or service meshes that enforce authentication and deny unauthenticated access to debug, profiling, and logging paths.
  • Network monitoring and HTTP access logs to detect anomalous requests to /serveLogs, /debug, or similar endpoints from untrusted sources.

Sources

SourceLink
github.comgithub.com/gpustack/gpustack/commit/4e20551b5aaf76f93a8769d32b7fef999e22a4d3
github.comgithub.com/gpustack/gpustack/issues/5836
vulncheck.comvulncheck.com/advisories/gpustack-unauthenticated-information-disclosure-via-worker-endpoints

Frequently asked

questions

Exploitability depends on how widely the worker port is exposed. In environments where workers are reachable from shared networks, multi-tenant clusters, or the internet, any unauthenticated client can interact with the vulnerable endpoints.

An attacker needs only network access to the GPUStack worker port; no credentials, tokens, or prior foothold are required to read logs or adjust log-related configuration through these endpoints.

The safest pattern is to require strong authentication and role-based authorization for all debug, logging, and configuration endpoints, and to separate them from public serving traffic. Where possible, disable or tightly restrict these endpoints in production environments.

Adopt a security-by-design approach for operational APIs: classify debug and logging routes as sensitive, enforce authentication and authorization by default, run them behind controlled admin interfaces or networks, and include checks for unauthenticated critical functions in code review and automated security testing pipelines.

Find out what's already
exploitable in your codebase.