CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-56825

CVE-2026-56825: Missing Authorization and State Tampering in Shopper e-commerce Admin Panel

Alon Barad
Alon Barad
Software Engineer

Sep 15, 2026·9 min read·21 visits

Executive Summary (TL;DR)

An authenticated attacker with only low-level collection browsing access can exploit insecure Livewire state handling and missing authorization checks to detach products or empty arbitrary collections in the Shopper admin panel, disrupting catalog integrity and storefront presentation.

A critical authorization bypass and insecure direct object reference (IDOR) vulnerability was discovered in Shopper, a Headless e-commerce Admin Panel. Due to missing authorization chains on table actions and the lack of a locked property on the collection state model, authenticated low-privilege staff can detach products from arbitrary collections.

Vulnerability Overview

The Shopper Headless e-commerce Admin Panel is built on top of Laravel, utilizing the Livewire framework to enable dynamic, real-time interface rendering. This design pattern relies on frequent asynchronous HTTP communications between the frontend client and backend controller components to keep state synchronized. The administrative dashboard exposes a collection management interface where administrators can group products into curated lists for promotional or navigation purposes.

Within this interface, the component located at packages/admin/src/Livewire/Components/Collection/CollectionProducts.php handles operations such as viewing, adding, and removing products associated with specific collections. Because the dashboard controls essential frontend storefront landing pages and category catalogs, the integrity of these collections is critical to maintaining e-commerce availability. The attack surface of this component is exposed to any authenticated user who has access to the admin panel endpoints, even those holding restricted, lower-privilege roles.

This specific security advisory concerns a critical missing authorization check combined with client-mutable state tampering. The combination of these two weaknesses allows an authenticated attacker to detach products from collections that they should not have the ability to modify or interact with. This action bypasses the standard privilege verification mechanisms enforced elsewhere in the application, violating the principle of least privilege.

Ultimately, this vulnerability represents a failure in both access control enforcement and secure state management. By targeting the Livewire update endpoint, unauthorized actors can systematically break category associations, corrupt promotional landings, and impact catalog integrity across the store database. This technical analysis explores the underlying mechanics of this vulnerability, showing how insecure serialization combined with unguarded administrative endpoints leads to privilege escalation.

Root Cause Analysis

To understand the underlying mechanics of CVE-2026-56825, one must analyze the state synchronization architecture of Laravel Livewire and Filament-style action tables. Livewire operates by serializing (or dehydrating) public PHP class properties into a JSON metadata payload called a 'snapshot' which is transmitted to the client's browser. When the client invokes a user interface action, this snapshot is sent back to the server, where Livewire deserializes (or rehydrates) the properties to restore the server-side state.

In vulnerable versions of Shopper, the component CollectionProducts declares a public model property representing the active collection: public Collection $collection;. By default in this implementation, Livewire does not verify the integrity of public properties against client-side tampering unless specifically instructed to do so. Because this public model is exposed without the Livewire #[Locked] attribute, an attacker can modify the model's identifier inside the serialized JSON state payload during transit.

When a subsequent Livewire request is made, the backend framework rehydrates the Eloquent model using the attacker-modified ID. Because there is no cryptographic signature validating that the ID matches the one originally supplied by the server, the framework loads the substituted collection. This allows an attacker to perform an Insecure Direct Object Reference (IDOR) to access arbitrary collections in the database, even if they were originally interacting with a different, perhaps authorized, collection.

This issue is severely compounded by a missing authorization check inside the table action handlers. The administrative table defining the product association exposes single-row delete actions (Action::make('delete')) and bulk-delete actions (DeleteBulkAction::make()). Neither of these actions invokes an ->authorize(...) method chain. Consequently, Filament and Livewire execute the underlying SQL detach commands without validating whether the authenticated user possesses the delete_collections permission. The system executes the deletion based solely on the rehydrated, attacker-tampered collection model.

Code Analysis

The vulnerable implementation of CollectionProducts.php demonstrates the lack of administrative guards. Below is the comparative analysis showing the code block before and after the application of the official security patch.

// BEFORE PATCH (Vulnerable Code)
class CollectionProducts extends Component implements HasActions, HasSchemas, HasTable
{
    use InteractsWithSchemas;
    use InteractsWithTable;
 
    // The public property is completely unprotected, allowing client-side modification
    public Collection $collection;
 
    public function table(Table $table): Table
    {
        return $table
            ->recordActions([
                Action::make('delete')
                    // Missing ->authorize('delete_collections') check
                    ->label(__('shopper::forms.actions.delete'))
                    ->icon(Untitledui::Trash03)
                    ->action(function (Product $record): void {
                        $this->collection->products()->detach([$record->id]);
                    }),
            ])
            ->groupedBulkActions([
                DeleteBulkAction::make()
                    // Missing ->authorize('delete_collections') check
                    ->label(__('shopper::forms.actions.delete'))
                    ->icon(Untitledui::Trash03)
                    ->action(function (EloquentCollection $records): void {
                        $this->collection->products()->detach($records->pluck('id')->toArray());
                    }),
            ]);
    }
}

The corresponding patch introduces the necessary architectural safeguards. First, the #[Locked] attribute is imported and prepended to the public $collection property. This prevents clients from mutating the model ID because Livewire now signs the property and verifies the signature on subsequent requests. Second, both actions are updated to enforce authorization via the ->authorize('delete_collections') method chain.

// AFTER PATCH (Secure Code)
use Livewire\Attributes\Locked;
 
class CollectionProducts extends Component implements HasActions, HasSchemas, HasTable
{
    use InteractsWithSchemas;
    use InteractsWithTable;
 
    // The locked attribute prevents client-side mutation of this property
    #[Locked]
    public Collection $collection;
 
    public function table(Table $table): Table
    {
        return $table
            ->recordActions([
                Action::make('delete')
                    // Explicitly authorizes the action before execution
                    ->authorize('delete_collections')
                    ->label(__('shopper::forms.actions.delete'))
                    ->icon(Untitledui::Trash03)
                    ->action(function (Product $record): void {
                        $this->collection->products()->detach([$record->id]);
                    }),
            ])
            ->groupedBulkActions([
                DeleteBulkAction::make()
                    // Explicitly authorizes the bulk action before execution
                    ->authorize('delete_collections')
                    ->label(__('shopper::forms.actions.delete'))
                    ->icon(Untitledui::Trash03)
                    ->action(function (EloquentCollection $records): void {
                        $this->collection->products()->detach($records->pluck('id')->toArray());
                    }),
            ]);
    }
}

The fix is robust because it addresses both vectors: even if an attacker attempts to call the action directly on a valid collection, the authorization check blocks the request. Concurrently, if the attacker attempts an IDOR attack to target a different collection, the #[Locked] validation fails, raising a serialization exception. This layered approach completely seals the affected code path.

Exploitation Methodology

To successfully exploit CVE-2026-56825, an attacker must satisfy specific preconditions. First, the attacker must hold active credentials for a dashboard account with low-level administrative permissions, such as the browse_collections role. This is an authenticated vulnerability, but it relies on low-privilege sessions to escalate permissions horizontally and vertically. Second, the attacker must have network access to the Livewire update endpoint located at /shopper/livewire/update.

The exploitation flow begins by identifying a target collection ID to disrupt. Because collection IDs are usually sequential integers, an attacker can enumerate identifiers easily. Using a browser-based interception proxy or custom tools, the attacker captures a legitimate Livewire interaction to obtain the structure of the component's state snapshot JSON block. Because the $collection model is not locked, its signature or checksum is not verified against modification of its database key.

Next, the attacker crafts a POST request to /shopper/livewire/update. The request body includes a snapshot JSON block where the data.collection ID is substituted with the target collection ID. The payload also declares a call to the callBulkAction method, passing the action name 'delete' and an array of product identifiers to detach. Upon receiving this request, the backend updates its internal state with the tampered collection ID, ignores the lack of permission on the current session, and executes the detachment database operation.

This exploitation results in the silent removal of product-to-collection relations. Because the response is processed as a standard Livewire DOM diff, the server returns an HTTP 200 OK, indicating successful execution. Security teams can monitor network transactions for anomalous calls to callBulkAction or callAction on the CollectionProducts component where the caller session lacks administrative read-write access.

Impact Assessment

The impact of CVE-2026-56825 is significant, particularly within e-commerce environments where site navigation and product catalog configurations are dynamic. An attacker who successfully exploits this vulnerability can detach products from any collection in the system. Because collections typically drive major portions of storefront landing pages, curated sales categories, and promotional banners, the immediate consequence is visual and structural disruption of the web application.

By emptying critical collections, an attacker can break active marketing campaigns, hide high-value inventory from customers, and degrade user trust. For instance, if a collection corresponding to a home page 'Featured Products' slider is emptied, the storefront may fail to display items, leading to lost conversions. This operational impact directly translates to a high Availability (A) and Integrity (I) score under CVSS 3.1.

Specifically, the CVSS 3.1 vector is evaluated as CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:H, resulting in a base score of 8.1. The attack is network-bound and exhibits low complexity, requiring only minimal standard credentials without user interaction. No direct data confidentiality breach occurs since the exploit does not leak database contents, but the high integrity damage allows unauthorized system modification.

Currently, this vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, and no active exploitation has been documented in the wild. However, because reproducible proof-of-concept exploits exist, organizations running Shopper are advised to treat this as a high-risk security issue. Prompt remediation is required to safeguard administrative interfaces and guarantee transactional uptime.

Remediation & Mitigation Guidance

The most effective and permanent solution to CVE-2026-56825 is upgrading the Shopper application to version 2.9.2 or higher. This release integrates secure state handling and comprehensive action-level authorization checks across several administrative components. Administrators should run the composer update command to fetch the latest secure release:

composer update shopperlabs/shopper

In scenarios where an immediate system-wide upgrade is prevented by operational constraints or dependency conflicts, a manual hotfix must be applied. Developers should manually edit the component file packages/admin/src/Livewire/Components/Collection/CollectionProducts.php. Prepend the #[Locked] attribute to the public $collection property, and chain the ->authorize('delete_collections') method onto both Action::make('delete') and DeleteBulkAction::make() definitions in the table() configuration method.

Additionally, security teams should implement defensive monitoring. Web Application Firewalls (WAFs) can be configured to inspect POST traffic directed to /shopper/livewire/update. Specifically, rules can flag requests containing the string CollectionProducts within the component snapshot payload when the request originates from users without explicit collection management authorization.

Finally, organizations should perform an audit of all custom Livewire components in their codebase. Developers must verify that any public model property bound to user interface actions is decorated with #[Locked]. Furthermore, any administrative action exposed via Filament tables or custom controllers must strictly call an authorization gate or permission check to prevent horizontal privilege escalation.

Official Patches

shopperlabsOfficial commit patch enforcing authorization and model locking.

Fix Analysis (1)

Technical Appendix

CVSS Score
8.1/ 10
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:H

Affected Systems

Shopper Headless e-commerce Admin Panel < 2.9.2

Affected Versions Detail

Product
Affected Versions
Fixed Version
shopper
shopperlabs
< 2.9.22.9.2
AttributeDetail
CWE IDCWE-862
Attack VectorNetwork
CVSS v3.18.1 (High)
Exploit StatusProof-of-Concept
CISA KEV StatusNot Listed
ImpactHigh Integrity & High Availability Damage
RemediationUpgrade to Shopper v2.9.2 or apply manual hotfix

MITRE ATT&CK Mapping

T1068Exploitation for Privilege Escalation
Privilege Escalation
CWE-862
Missing Authorization

The software does not perform an authorization check when an actor attempts to access a resource or perform an action, allowing unauthorized actors to perform administrative actions.

Known Exploits & Detection

GitHubSecurity advisory detailing administrative component authorization bypasses.

Vulnerability Timeline

Patch released in commit bf72e2753e21296184596d507336c7d65ecd46ff and version 2.9.2
2026-06-22

References & Sources

  • [1]GitHub Security Advisory GHSA-2cg9-97gq-9mqp
  • [2]Shopper Pull Request 570
  • [3]Shopper Fix Commit
  • [4]Shopper Release v2.9.2
  • [5]Wiz Vulnerability Analysis Entry

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•13 minutes ago•CVE-2026-55649
6.3

CVE-2026-55649: Stored Cross-Site Scripting in GeoNode Document Metadata Abstract Field

CVE-2026-55649 is a stored Cross-Site Scripting (XSS) vulnerability in GeoNode versions prior to 5.0.3. The flaw exists because document abstract metadata fields are ingested via the metadata management pipeline and stored in the backend database without HTML sanitization or input neutralization. An authenticated attacker with privileges to create or edit document metadata can inject arbitrary HTML and JavaScript payloads into these fields. When another user, such as an administrator, views the affected document page or catalog listing, the unencoded payload is rendered into the Document Object Model (DOM) and executes within the victim's browser session.

Amit Schendel
Amit Schendel
0 views•9 min read
•about 1 hour ago•GHSA-QX75-2P3R-PWM5
7.7

CVE-2026-55622: Cross-Project Instance Copy Authorization Bypass in Canonical LXD and LXC Incus

CVE-2026-55622 (GHSA-qx75-2p3r-pwm5) is an improper access control vulnerability (CWE-284) in Canonical LXD and LXC Incus (tracked as GHSA-c9f5-j9c3-mhrg). In multi-tenant deployments utilizing project-based isolation, the REST API handler for instance creation via POST /1.0/instances verifies that the authenticated user has authorization in the destination project specified by the query parameter, but fails to verify whether the user holds read or view permissions for the source instance when executing a copy operation across projects. Consequently, an authenticated client restricted to a single project can clone instances or snapshots from unauthorized projects into their own project, resulting in complete disclosure of the target instance filesystem and embedded credentials.

Amit Schendel
Amit Schendel
3 views•11 min read
•about 2 hours ago•GHSA-7MR3-28H5-M5VX
7.7

GHSA-7mr3-28h5-m5vx: Authorization Bypass and Cross-Project Volume Copy in Canonical LXD

An authorization bypass vulnerability in Canonical LXD (tracked as GHSA-7mr3-28h5-m5vx and CVE-2026-55621, and as GHSA-64f3-v33m-w89f in Linux Containers Incus) allows an authenticated user with restricted project access to copy custom storage volumes and volume snapshots from unauthorized projects. The flaw resides in the storagePoolVolumesPost REST API handler, which verifies permissions on the destination project but fails to check whether the caller holds view entitlements on the source project or volume specified in the request body.

Alon Barad
Alon Barad
3 views•10 min read
•about 3 hours ago•GHSA-47W9-6R3F-938G
9.9

GHSA-47w9-6r3f-938g: Authorization Bypass and Host Root Command Execution in Canonical LXD and Incus

A missing authorization and configuration validation vulnerability in Canonical LXD and LXC Incus allows authenticated users within restricted projects to bypass project security boundaries. By smuggling prohibited low-level configuration directives (such as raw.lxc or raw.qemu) inside instance snapshots or backup archives, an attacker can restore these configurations within a restricted project and execute arbitrary commands with root privileges on the underlying host operating system.

Alon Barad
Alon Barad
4 views•11 min read
•about 4 hours ago•GHSA-JPF8-86F3-WP38
9.9

CVE-2026-48752: Arbitrary Host File Read and Write via Templates Symlink in Canonical LXD and Incus

A symbolic link traversal vulnerability (CWE-59) in Canonical LXD and Linux Containers Incus allows an authenticated user with image import permissions to read and write arbitrary files on the host filesystem. During image archive unpacking, the daemon fails to reject top-level symbolic links for the instance `templates` directory. Subsequent requests to the instance template API endpoints follow this symbolic link outside the instance storage directory with root privileges, enabling complete host compromise.

Amit Schendel
Amit Schendel
4 views•10 min read
•1 day ago•CVE-2026-12411
8.4

CVE-2026-12411: Cross-Guest Volume Hijack via DevLXD Device PATCH in Canonical LXD

CVE-2026-12411 is a broken access control vulnerability in the DevLXD interface of Canonical LXD versions 6.6 through 6.8. The flaw resides in the devLXDInstancePatchHandler component, which fails to verify storage volume ownership when an instance attaches a new disk device via the /dev/lxd guest socket. When the security.devlxd.management.volumes configuration option is enabled, an untrusted guest or DevLXD identity can issue a crafted HTTP PATCH request referencing another tenant's custom storage volume. The LXD host daemon subsequently mounts the target volume into the requesting guest, permitting unauthorized cross-tenant read and write operations.

Amit Schendel
Amit Schendel
7 views•10 min read