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.

