/

CVE-2026-23517

Severity:

HIGH RISK

(8.1)

Broken Access Control in Fleet Device Management

CVE-2026-23517

Analyzed

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-862

Impact:

Information Disclosure and Denial of Service

Severity:

HIGH RISK

(8.1)

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

Fleet device management exposed debug and profiling endpoints to all authenticated users, regardless of their role.

Low-privilege accounts could access sensitive diagnostics and runtime profiling data and trigger CPU‑intensive operations, which may leak internal state and lead to denial of service under normal authenticated usage.

Affected context

This vulnerability appears in Fleet deployments where the built-in debug and /debug/pprof endpoints are reachable from authenticated users and where role-based access control is expected to limit access to operational and diagnostic functionality.

It is relevant in environments that:

  • Allow low-privilege or externally facing accounts to authenticate to Fleet
  • Run Fleet with debug/pprof HTTP handlers enabled and routable
  • Rely on Fleet's role model to restrict access to internal diagnostics rather than separate network controls

Exploit preconditions

  • Attack surface: Fleet HTTP API/UI endpoints, specifically debug and profiling routes (e.g., /debug/pprof).
  • Required access: Any valid authenticated Fleet account, including the lowest-privilege "Observer" role.
  • Trigger point: Directly browsing to or programmatically calling debug/pprof routes while logged in.
  • Why exploitation is possible: Role-based access checks are missing or incomplete for these endpoints, so the application does not distinguish between administrator and low-privilege users when serving sensitive diagnostics and executing profiling actions.

Why this happens

The issue is a classic broken access control problem, aligning with CWE-862: Missing Authorization.

Fleet exposes operational debug and profiling endpoints but fails to enforce role-based authorization on those routes, effectively treating "any authenticated user" as equivalent to an administrator for this subset of functionality.

This insecure pattern occurs when:

  • Sensitive operational or administrative endpoints are integrated into the main web server
  • Authentication is required, but fine-grained authorization is not checked
  • Debug/maintenance surfaces are not separated from user-facing application APIs

Potential impact

  • Low-privilege users may view detailed runtime profiling data (CPU, heap, goroutine traces) that could reveal:
  • Internal code paths and performance characteristics
  • In-memory data patterns and partial application state
  • Exposure of sensitive operational information that could assist in further attacks (e.g., timing behavior, endpoint discovery).
  • Ability for non-admin users to trigger CPU- or memory-intensive profiling, which can:
  • Degrade performance for legitimate users
  • Potentially lead to partial or full denial of service under load.
  • Increased risk surface if debug data includes incidental sensitive information, such as fragments of configuration, identifiers, or system topology.

General mitigation guidance

Mitigation typically focuses on enforcing strict authorization on diagnostic surfaces and minimizing exposure of operational endpoints:

  • Treat debug and profiling handlers as privileged operations and gate them behind explicit role checks or a dedicated "operator/admin" permission.
  • Isolate operational/debug endpoints from regular application traffic, for example by:
  • Binding them to a separate listener or port
  • Restricting them via network controls (internal-only, IP allowlists, VPN access).
  • Apply the principle of least privilege to in-app roles so that only designated operational accounts can see runtime diagnostics.
  • When possible, disable or limit high-cost profiling operations in production, or require an additional explicit confirmation or temporary elevation path.
  • Regularly review routes that expose system internals to ensure they follow the same authorization model as other administrative features.

How teams detect issues like this

Detection and assurance can rely on a combination of code-level and operational checks:

  • Static analysis / code scanning:
  • Search for debug/pprof or similar diagnostic handlers registered without accompanying authorization middleware.
  • Flag endpoints mounted under /debug, /pprof, or equivalent paths that only check authentication but not authorization.
  • Code review practices:
  • Include "administrative/debug endpoint" review checklists to ensure every such route has an explicit permission or role check.
  • Trace the middleware stack for sensitive routes to confirm they use the same RBAC enforcement as core admin APIs.
  • Runtime monitoring:
  • Log and monitor access to debug/pprof endpoints, alerting on use by non-privileged roles or unusual access patterns.
  • Correlate spikes in profiling endpoint calls with CPU or latency anomalies to detect abuse leading to DoS.
  • Automated policy enforcement:
  • Use security testing tools or custom integration tests that attempt to access sensitive endpoints with low-privilege accounts and fail builds when access is granted.

Sources

SourceLink
github.comgithub.com/fleetdm/fleet/commit/5c030e32a3a9bc512355b5e1bf19636e4e6d0317
github.comgithub.com/fleetdm/fleet/security/advisories/GHSA-4r5r-ccr6-q6f6

Frequently asked

questions

Yes, but only by users who can authenticate to the Fleet instance. Any valid account, including low-privilege roles, can access the affected debug and profiling endpoints if the instance is exposed over the network.

No. The core issue is that the debug/pprof endpoints do not enforce role-based authorization, so even the lowest-privilege "Observer" role can reach them as long as the user is authenticated.

Ensure that all debug and profiling routes are treated as privileged operations, applying explicit authorization checks tied to a high-privilege role (e.g., administrator or operator), or isolating these endpoints behind separate network protections where only trusted operators can reach them.

Adopt a consistent access control strategy in which every endpoint—especially debug, maintenance, and operational interfaces—must declare its required authorization, enforced via common middleware. Combine this with network-layer protections for diagnostic surfaces and routine security testing that verifies low-privilege accounts cannot access internal or high-impact operational functionality.

Find out what's already
exploitable in your codebase.