/

CVE-2026-46484

Severity:

HIGH RISK

(8.1)

Path Traversal Auth Bypass (CWE-22) in Headplane UI

CVE-2026-46484

Deferred

Vulnerability type

Category:

Path Traversal and Authorization Bypass

CWE:

CWE-22, CWE-285

Impact:

Unauthorized Access and Resource Manipulation

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

A path traversal and authorization bypass flaw in Headplane's Headscale API client lets rename operations for nodes and users send requests to unintended API endpoints.

When exploited in vulnerable versions, an attacker who can reach the Web UI may manipulate API paths to bypass normal access controls and affect resources they should not control.

Affected context

The vulnerability occurs in Headplane deployments integrated with a Headscale instance where the Web UI mediates node and user rename operations through an API client.

It is relevant when the API client constructs request paths using user-controllable input without strict normalization or access checks tied to the resolved path.

The issue is most impactful in environments where Headplane is exposed to multiple users or administrators with differing authorization levels.

Exploit preconditions

  • Attack surface: HTTP interface of the Headplane Web UI and its backend API client to Headscale.
  • Required access: Ability to trigger node or user rename actions, typically via authenticated or reachable Web UI endpoints.
  • Trigger point: Submission of crafted rename input that alters the effective API path used by the Headscale client.
  • Why exploitation is possible: User-controlled path elements are insufficiently validated or normalized, allowing traversal-like behavior that bypasses intended authorization checks on the targeted resource.

Why this happens

The core issue stems from constructing backend API request paths from user-supplied data without robust path normalization and enforcement of resource-level authorization.

This maps to CWE-22 (Path Traversal), where attacker-controlled path segments influence the resolved target beyond what the application intends, and CWE-285 (Improper Authorization), where access control is applied based on assumed, not verified, resource identities.

Conceptually, the API client trusts that rename inputs refer only to permitted resources, instead of determining authorization from the final resolved resource and enforcing strict policy there.

Potential impact

  • Attackers may rename nodes or users they are not authorized to manage.
  • Unauthorized modification of configuration or metadata associated with other tenants or administrative domains.
  • Disruption of network identity mappings, leading to connectivity or routing issues.
  • Potential stepping stone for broader account or infrastructure misconfiguration if names are used in scripts, policies, or automation.

General mitigation guidance

Effective mitigation focuses on strict path handling and consistent authorization at the resource level.

Common defensive patterns include:

  • Normalizing and validating path segments before constructing backend API calls, rejecting any input that introduces traversal-like patterns or unexpected separators.
  • Using parameterized resource identifiers (e.g., IDs) rather than raw user-supplied path fragments to build API routes.
  • Enforcing authorization based on the resolved resource identity, not on user-supplied names, ensuring the caller has explicit rights to the node or user being renamed.
  • Applying least-privilege design in the Web UI and API client, limiting the scope of operations each requester can perform.
  • Centralizing access-control checks so that rename and similar operations reuse the same robust authorization logic as other sensitive actions.

How teams detect issues like this

Organizations can detect similar vulnerabilities through:

  • Static analysis rules that flag direct concatenation of user input into URL or file paths used by backend clients.
  • Code review practices that require explicit validation and normalization for all path-like parameters passed to internal APIs.
  • Logging and monitoring of rename and other administrative operations, with alerts on unusual targets, cross-tenant patterns, or high-volume rename activity.
  • Security testing that includes fuzzing of path-related parameters and manual attempts to reference resources outside the current user's scope.

Sources

SourceLink
github.comgithub.com/tale/headplane/releases/tag/v0.6.3
github.comgithub.com/tale/headplane/releases/tag/v0.7.0-beta.3
github.comgithub.com/tale/headplane/security/advisories/GHSA-vgj6-hcf2-fqf6

Frequently asked

questions

It can be remotely exploitable if the Headplane Web UI is exposed over the network and accessible to attackers who can reach the rename endpoints, subject to whatever authentication the deployment requires.

Typically, the attacker must have the ability to invoke the node or user rename functionality.

The core risk is that once they have that capability, insufficient checks may allow them to affect resources beyond their intended authorization scope.

The safest fix is to avoid constructing backend API paths directly from user input and instead use validated, canonical identifiers, combined with centralized authorization checks that verify the caller's rights on the target resource before performing the rename.

Adopt secure coding patterns for all path handling, enforce strict access-control checks for every resource-modifying operation, mandate security-focused code reviews for API client logic, and use automated analysis to flag any use of untrusted input in path construction or authorization decisions.

Find out what's already
exploitable in your codebase.