/

CVE-2026-47740

Severity:

HIGH RISK

(8.1)

Broken Access Control in Shopper Headless E-commerce Admin

CVE-2026-47740

Deferred

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-285, CWE-862

Impact:

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

Shopper's admin panel exposed multiple high-impact order and shipment actions to users who only had read-level permissions.

An authenticated low-privilege user with access to view orders could change order lifecycle states and even trigger real-world payment captures, bypassing intended authorization checks.

Affected context

This vulnerability appears in Shopper deployments where:

  • The Filament-based admin panel is exposed to internal staff, partners, or support users.
  • Role-based permissions differentiate between read-only and mutating capabilities for orders and shipments.
  • Low-privilege accounts are granted read_orders and/or browse_orders access, but should not be allowed to mutate orders (edit_orders) or shipments.

In such environments, order detail actions (cancel, mark paid, mark complete, capture payment, archive, start processing) and shipments table actions (mark delivered, edit tracking) could be invoked by users lacking the corresponding edit permissions.

Exploit preconditions

  • Attack surface: Shopper admin panel (web interface / associated HTTP endpoints).
  • Required access:
  • A valid, authenticated low-privilege user account.
  • Permissions such as read_orders and/or browse_orders, but not edit_orders.
  • Trigger point:
  • Invoking Filament actions on the order detail page (e.g., cancel, mark paid, mark complete, capture payment, archive, start processing).
  • Invoking actions on the order shipments table (e.g., mark delivered, edit tracking).
  • Why exploitation is possible:
  • Server-side authorization checks for these actions rely only on the user being authenticated and able to view orders, rather than enforcing the stricter edit-level permission.
  • The action handlers execute state changes and external side effects (such as PSP capture) without verifying that the caller possesses the necessary mutation privileges.

Why this happens

The core issue is incomplete server-side authorization on sensitive business operations.

While Shopper defines different permission levels (e.g., read_orders, browse_orders, edit_orders), some Filament actions on order and shipment records were wired to require only read-level access.

This maps to:

  • CWE-285: Improper Authorization – the system fails to enforce the proper permission required for invoking high-impact actions.
  • CWE-862: Missing Authorization – action endpoints effectively lack checks for the specific edit privileges that should guard state-changing operations and external payment captures.

Architecturally, the bug reflects a mismatch between the UI-visible roles and the deeper business rules enforcing who may transition orders between lifecycle states or initiate payment captures.

Potential impact

  • A low-privilege user with read access could:
  • Cancel arbitrary orders.
  • Mark unpaid orders as paid or complete without proper authorization.
  • Trigger real-world payment captures via the PSP for any eligible order.
  • Archive or mark orders as "processing", corrupting operational workflows.
  • Mark shipments as delivered, affecting customer communication and dispute resolution.
  • Modify shipment tracking data, undermining logistics and audit trails.
  • Financial risk due to unintended or fraudulent captures and refunds.
  • Loss of data integrity in order and shipment lifecycles.
  • Reputational damage if customers are impacted by incorrect payment or fulfillment status.

General mitigation guidance

Long-term mitigation focuses on tightening and centralizing authorization logic for business operations:

  • Enforce server-side permission checks per action:
  • Explicitly require edit-level permissions (e.g., edit_orders) for any state-changing order or shipment actions.
  • Ensure that external side-effect operations (like PSP captures) are guarded by the strictest relevant role.
  • Adopt a policy-based authorization layer:
  • Use a centralized policy or gate mechanism that determines whether a user can perform a particular domain action (e.g., capturePayment, markDelivered) independently of UI-level visibility.
  • Express rules in business terms (role, order state, ownership) rather than only controller or route names.
  • Secure-by-default role design:
  • Default new roles to read-only for sensitive resources, requiring explicit opt-in for mutation capabilities.
  • Avoid coupling read and write permissions; keep view and mutate privileges separate and minimal.
  • Harden high-risk actions:
  • Add additional safeguards for payment-related operations, such as secondary permission checks, explicit confirmation flows, or dual-control for especially risky transitions.
  • Log and audit all state changes and payment transitions to support monitoring and incident response.

How teams detect issues like this

Effective detection involves both preventative checks in development and monitoring in production:

  • Static and configuration analysis:
  • Scan action definitions and controller handlers to ensure that each mutating operation checks for the correct permission (e.g., edit_orders).
  • Flag any Filament action or route that performs order/shipment state changes without explicit authorization guards.
  • Code review practices:
  • During reviews, verify that every new or modified business action (order lifecycle, shipment status, payment interaction) references a consistent authorization policy.
  • Look for discrepancies where UI visibility is restricted, but server-side checks are not aligned.
  • Automated policy enforcement:
  • Employ automated security tests or linters that enforce a convention (e.g., "all actions changing order status must call a common authorization helper").
  • Integrate these checks into CI pipelines so regressions are caught before deployment.
  • Runtime monitoring and auditing:
  • Enable detailed logging of order and shipment state transitions, including actor identity, prior state, and resulting state.
  • Analyze logs for anomalous patterns, such as low-privilege roles performing high-risk actions or spikes in payment captures from unexpected accounts.

Sources

SourceLink
github.comgithub.com/shopperlabs/shopper/pull/511
github.comgithub.com/shopperlabs/shopper/security/advisories/GHSA-f946-9qp6-vgch

Frequently asked

questions

Any authenticated user of the Shopper admin panel with read-level permissions on orders or shipments could exploit the issue. No direct anonymous or public access is involved, but internal users, support accounts, or compromised low-privilege accounts could invoke the affected actions.

No. The vulnerability specifically allows users with read-only permissions like read_orders or browse_orders—who should not have edit_orders—to invoke high-impact order and shipment actions, effectively escalating their capabilities.

The safest pattern is to enforce strict, centralized authorization for each domain action. Every state-changing operation on orders or shipments and every payment-related call should verify that the caller holds the appropriate edit-level or domain-specific permission, independent of UI constraints.

Prevent them by adopting a defense-in-depth authorization strategy: define clear, granular permissions; centralize policy checks; require explicit authorization calls for all mutating operations; and add automated tests and linters that fail builds when actions lack appropriate permission verification. Regularly reviewing audit logs and performing role/permission reviews also helps catch misconfigurations early.

Find out what's already
exploitable in your codebase.