/

CVE-2026-92762

Severity:

HIGH RISK

(8.8)

Missing Authorization (CWE-862) in Pelican Panel Startup

CVE-2026-92762

Deferred

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Arbitrary Command Execution

Severity:

HIGH RISK

(8.8)

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

Pelican Panel fails to enforce server-side authorization for startup settings, relying instead on disabled form controls in the user interface. An attacker with startup.read permission may manipulate Livewire state updates to change startup commands, container images, or environment variables and execute arbitrary commands inside the container.

Affected context

The vulnerability occurs in Pelican Panel startup configuration workflows when authorization is enforced only through client-side form-control state rather than backend permission checks. It affects deployments where a user has permission to view startup settings and can submit crafted Livewire state updates that reach startup-field callbacks.

Exploit preconditions

  • Attack surface: Pelican Panel's Livewire startup configuration interface
  • Required access: An authenticated account with startup.read permission
  • Trigger point: A crafted Livewire state update invoking afterStateUpdated callbacks
  • Affected data: Startup commands, Docker image references, and startup variables
  • Why exploitation is possible: The server processes sensitive state changes without independently verifying the required write permissions

Why this happens

The underlying flaw is a missing server-side authorization check, mapping to CWE-862: Missing Authorization. The application treats disabled form controls as an access-control boundary, but client-side UI restrictions do not prevent a caller from submitting alternate state data directly. When backend callbacks accept and process that data without validating write privileges, read-authorized users may alter protected startup configuration.

Potential impact

  • An attacker may execute arbitrary commands within the affected container
  • Application secrets and mounted data could be exposed or modified
  • Startup behavior could be altered to persist unauthorized actions
  • A compromised container could be used for lateral movement, depending on runtime privileges
  • Malicious image or variable changes could disrupt workloads or enable supply-chain abuse

General mitigation guidance

Mitigation generally focuses on enforcing authorization at every server-side state transition rather than relying on disabled controls or other client-side restrictions.

Common defensive patterns include:

  • Require explicit write authorization before processing startup mutations and callbacks
  • Treat all Livewire state and form submissions as untrusted input
  • Separate read and write permission checks at the service or policy layer
  • Validate startup commands, image references, and variables against strict schemas and deployment policy
  • Run containers with least privilege and restrict sensitive mounts and capabilities
  • Apply secure-by-default controls that prevent unauthorized startup configuration changes

How teams detect issues like this

Organizations can look for this class of issue through:

  • Static analysis of Livewire actions and callbacks for missing policy or permission checks
  • Code review checks confirming authorization occurs on the server before state mutation
  • Tests that submit direct or altered component-state requests using read-only accounts
  • Monitoring for unexpected changes to startup commands, images, and environment variables
  • Policy enforcement requiring distinct read and write permissions for administrative settings

Automated application-security review tools may help identify mutation handlers that lack authorization enforcement.

Sources

SourceLink
github.comgithub.com/pelican/panel
github.comgithub.com/pelican/panel/blob/fab5da496f7d837574b404e34dc42764a1d6b2c3/app/Filament/Server/Pages/Startup.php#L52-L77
github.comgithub.com/pelican/panel/security/advisories/GHSA-4x28-f89q-2276
vulncheck.comvulncheck.com/advisories/pelican-panel-before-1.0.0-beta35-authorization-bypass-via-startup

Frequently asked

questions

It may be exploitable through the Pelican Panel web interface when an attacker can authenticate and submit crafted Livewire requests. Exploitability depends on network exposure and the permissions assigned to the account.

The described condition requires an account with startup.read permission. The attacker does not necessarily need explicit startup write permission if the server fails to enforce that distinction.

Enforce authorization server-side for every startup mutation, including Livewire callbacks and state updates, and do not treat disabled form controls as security controls.

Use centralized authorization policies, test direct requests with read-only identities, validate sensitive configuration changes, and apply least privilege to the resulting containers.

Find out what's already
exploitable in your codebase.