/

CVE-2026-34358

Severity:

HIGH RISK

(8.1)

Broken Access Control in CtrlPanel Admin Write Controllers

CVE-2026-34358

Deferred

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-284, CWE-862

Impact:

Privilege Escalation and Unauthorized Data 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

CtrlPanel versions 1.1.1 and earlier contain a broken access control flaw where many admin controllers enforce RBAC on form display actions but omit equivalent checks on the corresponding write actions.

Any authenticated user can directly invoke POST/PATCH endpoints such as store() and update() to perform privileged operations, leading to full privilege escalation and unauthorized manipulation of billing, products, servers, and user accounts.

Affected context

The vulnerability appears in CtrlPanel's administrative HTTP controllers that expose both read/form-display and write endpoints.

In affected versions (1.1.1 and prior), permission checks are applied to methods that render forms or pages, but the matching store() and update() handlers either lack equivalent authorization checks or expose empty stubs that still accept and process incoming requests.

This pattern affects controllers such as ApplicationApiController, CouponController, PartnerController, ShopProductController, UsefulLinkController, VoucherController, ProductController, ServerController, UserController, and ActivityLogController when deployed with any configuration that permits non-admin users to authenticate.

Exploit preconditions

  • Attack surface: Web application admin and API endpoints handling POST/PATCH requests for administrative resources.
  • Required access: Any valid authenticated account; no administrative role or explicit write permission is needed.
  • Trigger point: Directly calling vulnerable write methods (store(), update(), and specific update variants) via crafted HTTP requests, bypassing the UI-based permission checks.
  • Why exploitation is possible: Authorization logic is bound to form-display or edit actions (e.g., index/show/edit) but not consistently enforced on the server-side write actions, creating a mismatch between the UI's RBAC and actual backend enforcement. The server trusts that only authorized users will reach these endpoints, which is not guaranteed.

Why this happens

The underlying issue is a classic case of missing or inconsistent authorization checks on privileged operations, mapped to:

  • CWE-284: Improper Access Control, where critical functions are exposed without enforcing the intended permission model.
  • CWE-862: Missing Authorization, because the write methods (store(), update(), and their variants) do not verify that the caller has the corresponding admin.*.write or other specific capabilities.

Instead of centralizing authorization at the business-logic layer, CtrlPanel relied on checks in form display methods (e.g., create/edit actions) and assumed that users would reach write endpoints only through those UI flows.

Attackers can bypass the UI entirely by issuing direct HTTP requests, revealing that the core sensitive operations—issuing API credentials, changing product prices, modifying user roles, or reassessing ownership—are not guarded by robust, server-side authorization.

Potential impact

  • Any authenticated user may escalate privileges by granting themselves admin-equivalent roles or capabilities.
  • API credentials can be created or modified, potentially enabling programmatic abuse of hosting infrastructure.
  • Unlimited coupons and vouchers can be generated, leading to financial loss and billing fraud.
  • Partner commission and discount rates can be set arbitrarily, impacting revenue distribution and accounting.
  • Shop product prices, limits, and parameters can be changed, undermining pricing integrity and resource quotas.
  • Server ownership and identifiers can be reassigned, enabling takeover of hosted resources or disruption of customer services.
  • User accounts can be modified, including credits, passwords, roles, referral links, and associated Pterodactyl IDs, compromising account security and auditability.
  • Activity log endpoints accepting arbitrary requests can dilute or pollute audit trails, hampering incident response.
  • Abuse of logBackIn() without proper login_as permission can interfere with or hijack admin impersonation sessions.

General mitigation guidance

Effective mitigation focuses on enforcing consistent, centralized authorization for all sensitive operations:

  • Ensure every state-changing controller method (store(), update(), delete(), and custom write actions) performs explicit permission checks that mirror or strengthen those used on corresponding read/form-display methods.
  • Move permission enforcement into a shared middleware, policy layer, or service that validates the caller's role and permissions at the business-logic boundary, not just at the UI routing level.
  • Treat all admin endpoints as untrusted entry points: require explicit checks for actions such as issuing credentials, changing financial parameters, altering resource ownership, or modifying user roles.
  • Apply the principle of least privilege by designing roles so that non-admin accounts cannot reach highly privileged operations, even if a missing check is introduced later.
  • Introduce defense-in-depth controls such as secondary confirmation or workflow approvals for especially sensitive changes (e.g., role changes, credit adjustments, ownership transfers).
  • Regularly review permission mappings and controller structures to avoid "check on read but not on write" patterns, especially when adding new methods or refactoring controllers.

How teams detect issues like this

Detection can leverage both code-centric and operational techniques:

  • Static analysis and linting:
  • Search for controller methods that perform writes (store, update, destroy, change_* actions) and ensure they invoke common authorization helpers, middleware, or policy checks.
  • Flag routes under admin namespaces that lack explicit permission checks or rely solely on client-side gating.
  • Code review practices:
  • During review, require that any new or modified admin route explicitly documents and implements its authorization requirements.
  • Look for mismatches where create/edit actions check permissions but store/update equivalents do not.
  • Automated policy enforcement:
  • Integrate security checks into CI pipelines to enforce that all routes tagged as admin or privileged must pass through a shared authorization layer.
  • Maintain a mapping of permissions to endpoints and automatically validate that every admin.*.write-like capability is enforced where necessary.
  • Runtime monitoring:
  • Monitor logs for suspicious patterns, such as low-privilege users invoking admin write endpoints or making frequent PATCH/POST requests to admin controllers.
  • Configure alerts for unexpected changes to roles, credits, ownership, and pricing parameters, which can indicate exploitation of missing authorization.

Sources

SourceLink
github.comgithub.com/Ctrlpanel-gg/panel/releases/tag/1.2.0
github.comgithub.com/Ctrlpanel-gg/panel/security/advisories/GHSA-pxmw-gj52-9p68

Frequently asked

questions

Yes. Any authenticated user with network access to the CtrlPanel interface can exploit it by directly calling vulnerable admin write endpoints, without needing administrative privileges.

The attacker needs a valid, non-admin user account or any account allowed to log in. From there, they can craft POST/PATCH requests to the affected controllers to perform actions normally restricted to admins.

The robust fix is to enforce authorization at every state-changing endpoint by using a centralized policy or middleware mechanism. Each write action (store, update, delete, and specialized change_* methods) should validate that the caller holds the correct role or permission, independent of how the request is initiated.

Adopt a "deny by default" design for admin endpoints, require explicit permission checks for all privileged operations, and back this with automated tests and static analysis that verify every write controller is protected. Embedding authorization rules in shared services or policies and continuously reviewing RBAC mappings reduces the risk of accidentally exposing unguarded admin operations.

Find out what's already
exploitable in your codebase.