/

CVE-2026-26016

Severity:

HIGH RISK

(8.1)

Broken Access Control in Pterodactyl Wings Node Server

CVE-2026-26016

Analyzed

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-283, CWE-639

Impact:

Unauthorized Access to Sensitive Data and Cross-Node Server 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 missing authorization check in multiple Wings controllers allows any party with a valid node secret token to fetch and manipulate information about servers on other nodes within a Pterodactyl deployment.

This broken access control condition can expose sensitive installation scripts, leak secrets, and allow manipulation of installation and transfer status for servers the node should not be able to manage.

Affected context

This vulnerability affects Pterodactyl deployments using Wings where:

  • Multiple Wings nodes are registered against a single panel instance
  • Each node uses a long-lived secret token stored in configuration (e.g., /etc/pterodactyl/config.yml)
  • Wings APIs trust node tokens for server-related operations without verifying node-server ownership

In such environments, any node that becomes compromised or misused can request data and perform actions on servers assigned to different nodes, exceeding its intended scope.

Exploit preconditions

  • Attack surface: Wings API endpoints that:
  • Return server details and installation scripts
  • Update installation status
  • Update transfer status between nodes
  • Required access:
  • Possession of a valid Wings node daemon token (node secret access token)
  • Network reachability to the panel/Wings API
  • Trigger point:
  • Calling server-related endpoints while authenticated as a node that is not the server's assigned node
  • Why exploitation is possible:
  • The authorization layer validates that the caller has a valid node token but does not verify that the requesting node is the one associated with the target server
  • This aligns with CWE-283: Unverified Ownership and CWE-639: Insecure Direct Object Reference by failing to ensure that an authenticated node is authorized for the specific server resource it is acting upon.

Why this happens

The root cause is an authorization logic gap in Wings controller handlers that manage server installation and transfer operations.

The code correctly checks that the caller presents a valid node token, but it stops there and does not enforce a second-level check ensuring that:

  • The server being queried or modified is bound to the same node as the token being used.

This pattern matches CWE-639 (Authorization Bypass Through User-Controlled Key) because the server identifier (or equivalent resource key) can be manipulated by an authenticated node to target resources it does not own, and CWE-283 (Unverified Ownership) because the system fails to verify the caller's ownership or scope when performing sensitive actions.

Instead of tying every server operation to its associated node identity, the design implicitly trusts any authenticated node to act on any server, resulting in over-broad access across the deployment.

Potential impact

  • Exposure of server installation scripts, which may contain embedded secrets or configuration values
  • Unauthorized reading of sensitive server configuration details across all nodes
  • Manipulation of server installation status on nodes the attacker does not control
  • Manipulation of server transfer status on nodes the attacker does not control
  • Lateral movement opportunities by harvesting credentials, tokens, or keys from other servers
  • Ability to trigger false transfer success, causing the panel to delete the server from the source node and potentially leading to irreversible data loss
  • Disruption of game server availability and potential denial of service conditions
  • Excessive or abusive notification sending related to manipulated install/transfer states

General mitigation guidance

Effective mitigation focuses on tightening authorization boundaries around node-scoped operations and hardening token handling:

  • Enforce node-to-server association checks:
  • For every server-related endpoint, ensure the handler verifies that the authenticated node's identity matches the node assigned to the target server record.
  • Deny or restrict operations where this association does not hold, and avoid implicit "any node" permissions.
  • Implement least-privilege for node tokens:
  • Scope node tokens to only the minimal set of APIs required for that node's responsibilities.
  • Treat node tokens as high-value secrets and restrict read access to configuration files where they are stored.
  • Harden resource access patterns:
  • Use server identifiers that are always resolved through an ownership-aware query, rather than trusting identifiers supplied in requests.
  • Centralize authorization logic so that all server operations pass through a consistent policy layer.
  • Improve secret handling in scripts and configs:
  • Avoid embedding long-lived or high-privilege secrets directly in installation scripts where possible.
  • Favor short-lived credentials, environment-based configuration, or indirection mechanisms that limit exposure if scripts are retrieved.
  • Operational safeguards:
  • Monitor for unusual cross-node access patterns or high volumes of server status changes.
  • Limit which systems and users can access node configuration files and consider additional host-level hardening.

How teams detect issues like this

Detection can focus on both code-level issues and runtime behavior:

  • Static analysis and code review:
  • Identify controller methods where:
  • Authorization checks validate only "is this a valid node?" but not "is this the correct node for this server?".
  • Server IDs or similar resource keys are taken directly from request parameters and used in queries without also filtering by the caller's node ID.
  • Look for patterns where a single node-scoped token is used to access or mutate arbitrary server records without additional filters.
  • Authorization policy enforcement:
  • Introduce a centralized authorization component or middleware that:
  • Always enforces node-server association checks for server operations.
  • Rejects operations on resources not bound to the authenticated principal (node).
  • Runtime logging and anomaly detection:
  • Log all calls to server installation and transfer endpoints with:
  • Authenticated node identity
  • Target server identity
  • Node assignment for the target server
  • Alert on:
  • Requests where the node identity and server-assigned node do not match
  • Sudden spikes in installation or transfer state changes, particularly across nodes.
  • Automated security testing:
  • Use integration tests or security scanners to simulate a node token accessing servers assigned to other nodes.
  • Incorporate these checks into CI/CD pipelines to prevent regressions in authorization logic.

Sources

SourceLink
github.comgithub.com/pterodactyl/panel/releases/tag/v1.12.1
github.comgithub.com/pterodactyl/panel/security/advisories/GHSA-g7vw-f8p5-c728

Frequently asked

questions

Exploitation is limited to situations where an attacker obtains a valid Wings node secret token and can reach the relevant APIs, but within that scope the attacker can access or manipulate servers across all nodes, not just the compromised node.

The attacker must obtain a Wings node daemon token, typically stored in plaintext in the node's configuration file. Without this token, they cannot authenticate to the vulnerable endpoints.

Enforce strict node-to-server association checks on all server-related endpoints, ensure that token-based authentication is coupled with resource-level authorization, and scope node tokens so they can only operate on resources explicitly assigned to their node.

Design APIs with least-privilege and explicit ownership checks, centralize authorization logic, validate that every access to a resource confirms both authentication and correct resource ownership, and use automated review and testing to detect cases where identifiers are used without corresponding scope checks.

Find out what's already
exploitable in your codebase.