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-103026

CVE-2026-103026: Arbitrary Method Invocation and State Tampering in Paymenter via Livewire HasConfirmation Trait

Alon Barad
Alon Barad
Software Engineer

Nov 20, 2026·9 min read·1 visit

Executive Summary (TL;DR)

A public method in Paymenter's base Livewire component allows remote callers to dynamically invoke any method on 36 frontend components. By calling the inherited fill() method, attackers can bypass Livewire's #[Locked] property protections and modify sensitive state variables, such as checkout totals, service pricing, and user associations.

Paymenter versions prior to 1.5.7 contain an arbitrary method invocation vulnerability within the base Livewire component architecture. The application includes a legacy trait, HasConfirmation, inside app/Livewire/Component.php, which is inherited across 36 client-facing Livewire components. This trait exposes a public remote procedure call (RPC) endpoint named executeConfirmedAction without access controls or method allowlisting. Remote attackers can invoke arbitrary methods on any inheriting component, including Livewire's internal fill() method, enabling them to bypass #[Locked] property protections and manipulate internal component state and hydrated Eloquent models.

Vulnerability Overview

Paymenter is an open-source webshop and billing management application built on Laravel and Livewire, designed for web hosting providers. In Laravel Livewire applications, interactive frontend interfaces are backed by server-side PHP component classes. Every public method defined on a Livewire component is automatically exposed as a callable remote procedure call (RPC) endpoint via the /livewire/update HTTP route.

Prior to version 1.5.7, Paymenter defined a base class App\Livewire\Component that extended the core \Livewire\Component class. This base class incorporated three traits: Disabled, HasConfirmation, and HasNotifications. Because 36 client-facing components across the platform—including Cart, Checkout, Services, Invoices, and User Profiles—extend App\Livewire\Component, any public method defined within those three traits became globally callable across the application's frontend attack surface.

The App\Livewire\Traits\HasConfirmation trait exposed a public method named executeConfirmedAction($action, $parameters = []). This method accepted a user-controlled string $action and an array of $parameters, and dynamically invoked $this->{$action}(...$parameters) on the active component instance. The implementation lacked an authorization check or an explicit method allowlist, relying solely on PHP's method_exists() function to validate the target prior to execution.

This flaw is classified under CWE-470 (Use of Externally-Controlled Input to Select Classes or Code), CWE-749 (Exposed Dangerous Method or Function), and CWE-915 (Improperly Controlled Modification of Dynamically-Determined Object Attributes). By abusing executeConfirmedAction to proxy calls into Livewire's inherited InteractsWithProperties::fill() method, an attacker can bypass Livewire's #[Locked] property integrity checks and overwrite arbitrary component properties and hydrated Eloquent model attributes.

Root Cause Analysis

The root cause of CVE-2026-103026 lies in the combination of Livewire's automatic RPC exposure of public methods and insecure dynamic method invocation inside App\Livewire\Traits\HasConfirmation. When Livewire processes an incoming component update request, it prevents direct client-side calls to internal framework lifecycle methods and restricts property mutations if those properties are annotated with the #[Locked] attribute.

However, when a request invokes executeConfirmedAction, Livewire validates the call against executeConfirmedAction itself—which is a standard public method defined in userland code. Once execution enters executeConfirmedAction, the method performs a dynamic call from within the class context ($this->{$action}(...$parameters)). Because this invocation occurs internally on $this, it bypasses Livewire's external RPC dispatch guards.

The primary escalation vector through this dynamic proxy is the fill($values) method, inherited from Livewire\Concerns\InteractsWithProperties. The fill() method is intended for server-side developers to bulk-assign properties during component initialization (such as inside mount()). Because fill() is declared as public on the base Livewire component, method_exists($this, 'fill') evaluates to true.

Internally, InteractsWithProperties::fill() iterates over the provided associative array and applies values to the component instance using Laravel's data_set($this, $property, $value) helper. Because data_set() operates directly on the PHP object in memory after Livewire has already hydrated and verified the component snapshot, it completely ignores the #[Locked] attribute. Furthermore, data_set() supports dot-notation traversal, allowing the caller to traverse into hydrated Eloquent models or nested arrays stored on the component and modify their internal attributes prior to database persistence or business logic execution.

Code Analysis

In vulnerable versions of Paymenter (< 1.5.7), the HasConfirmation trait was located at app/Livewire/Traits/HasConfirmation.php. It was designed to dispatch a frontend modal event via confirmAction and subsequently execute the confirmed callback via executeConfirmedAction.

<?php
 
namespace App\Livewire\Traits;
 
trait HasConfirmation
{
    public function confirmAction($action, $parameters = [], $title = null, $message = null, $confirmText = 'Confirm', $cancelText = 'Cancel')
    {
        $this->dispatch('show-confirmation', [
            'action' => $action,
            'parameters' => $parameters,
            'title' => $title ?? 'Are you sure?',
            'message' => $message ?? 'This action cannot be undone.',
            'confirmText' => $confirmText,
            'cancelText' => $cancelText,
        ]);
    }
 
    // VULNERABLE: Public method exposed as a Livewire RPC action on all child components.
    // No allowlist or authorization verification is performed on $action.
    public function executeConfirmedAction($action, $parameters = [])
    {
        if (method_exists($this, $action)) {
            // Dynamically invokes any method defined on the component or its parent classes/traits
            return $this->{$action}(...$parameters);
        }
 
        throw new \Exception("Method {$action} does not exist");
    }
}

This trait was attached globally in app/Livewire/Component.php, which serves as the parent class for client-facing components:

<?php
 
namespace App\Livewire;
 
use App\Livewire\Traits\Disabled;
use App\Livewire\Traits\HasConfirmation;
use App\Livewire\Traits\HasNotifications;
 
class Component extends \Livewire\Component
{
    use Disabled, HasConfirmation, HasNotifications;
    // ...
}

The vulnerability was remediated in commit e0c04af1707a65d8fb91879883aa7eae3292cedc. Upon review, the maintainers determined that HasConfirmation was legacy dead code that was not actively used by any component in the repository. Rather than attempting to filter or restrict the callable methods, the developers deleted app/Livewire/Traits/HasConfirmation.php entirely and removed the trait usage from app/Livewire/Component.php.

diff --git a/app/Livewire/Component.php b/app/Livewire/Component.php
index 3c95ce5823..42096900b0 100644
--- a/app/Livewire/Component.php
+++ b/app/Livewire/Component.php
@@ -9,7 +9,7 @@
 
 class Component extends \Livewire\Component
 {
-    use Disabled, HasConfirmation, HasNotifications;
+    use Disabled, HasNotifications;
 
     public function paginationView()
     {
diff --git a/app/Livewire/Traits/HasConfirmation.php b/app/Livewire/Traits/HasConfirmation.php
deleted file mode 100644
index 7b800238b5..0000000000
--- a/app/Livewire/Traits/HasConfirmation.php
+++ /dev/null
@@ -1,27 +0,0 @@
-<?php
-
-namespace App\Livewire\Traits;
-
-trait HasConfirmation
-{
...
-}

> [!NOTE] > Fix Completeness Assessment: Excising the HasConfirmation trait completely removes the executeConfirmedAction dynamic dispatch sink. Because the entire mechanism was deleted rather than patched with a blocklist or reflection check, there are no variant bypass opportunities (such as case-sensitivity mismatches or namespace prefixing) against this code path.

Exploitation

Exploiting CVE-2026-103026 requires network access to a Paymenter instance and the ability to interact with any page rendering a Livewire component that extends App\Livewire\Component. While the CVSS v3.1 vector specifies Low Privileges Required (PR:L)—reflecting authenticated customer portal components such as /services/{id} or /invoices—components rendered on guest-accessible routes (such as /cart, /checkout, or /register) can be exploited without authentication.

To execute the attack, the adversary first loads a target page and extracts two pieces of information from the HTML DOM: the Laravel CSRF token (_token) and the serialized component state located inside the wire:snapshot attribute of the target component element. The snapshot contains the component's initial property values, hydrated model references, and a cryptographic HMAC checksum (memo.checksum) verified by the server on every request.

Rather than modifying the snapshot or the updates object directly—which would trigger a checksum failure or a CannotUpdateLockedPropertyException—the attacker submits the unmodified snapshot to /livewire/update and places an entry in the calls array targeting executeConfirmedAction.

{
  "_token": "dGhpcyBpcyBhIcsrf_token_example",
  "components": [
    {
      "snapshot": "{\"data\":{\"total\":100,\"lockedProperty\":\"original\"},\"memo\":{\"id\":\"comp123\",\"name\":\"checkout\",\"checksum\":\"a1b2c3d4...\"}}",
      "updates": {},
      "calls": [
        {
          "path": "",
          "method": "executeConfirmedAction",
          "params": [
            "fill",
            [
              {
                "total": 0,
                "service.price": 0.00,
                "lockedProperty": "tampered_value"
              }
            ]
          ]
        }
      ]
    }
  ]
}

When the Paymenter backend processes this payload, Livewire verifies the incoming snapshot checksum, hydrates the component, and executes the requested call in the calls array. Furthermore, Livewire allows multiple method calls to be batched within the calls array in a single HTTP request. An attacker can chain a call to executeConfirmedAction('fill', [...]) as the first element in calls, immediately followed by a second call to a terminal business action (such as checkout(), pay(), or save()). The second method executes against the mutated in-memory component properties before the request lifecycle concludes.

Impact Assessment

The security impact of CVE-2026-103026 spans both unauthorized state modification and direct access control bypass across 36 frontend components. In Livewire, developers rely on the #[Locked] attribute to protect security-critical state stored on the component, such as model IDs, calculated cart totals, discount quantities, and ownership identifiers. Because executeConfirmedAction allows callers to invoke fill(), the integrity guarantee of #[Locked] is nullified across the entire application.

In financial and billing workflows, an attacker can manipulate properties governing order totals, item pricing, credit balances, or invoice status flags during checkout or payment processing. If a component holds a hydrated Eloquent model as a public property, dot-notation keys passed into fill() (e.g., order.user_id or service.status) directly mutate the model attributes in memory. If a subsequent action in the same request calls $this->model->save(), those tampered attributes are persisted directly to the database.

Beyond property tampering via fill(), executeConfirmedAction also permits the invocation of any protected or internal lifecycle method defined on the component or its traits, provided method_exists() returns true and the call originates from within the class hierarchy. Depending on the specific methods defined on the 36 inheriting components, attackers can trigger administrative or state-changing routines that were never intended to be exposed to user interaction.

The vulnerability carries a CVSS v3.1 base score of 8.1 (High) with the vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N. Both Confidentiality and Integrity impacts are rated High (C:H/I:H) due to the ability to rebind hydrated model identifiers (allowing Insecure Direct Object Reference conditions to read other users' records) and tamper with database-backed application state. At the time of writing, the EPSS score is 0.00364 (31st percentile), and the vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog.

Remediation

Operators running Paymenter must upgrade to version 1.5.7 or later, which includes commit e0c04af1707a65d8fb91879883aa7eae3292cedc. This release completely removes App\Livewire\Traits\HasConfirmation and detaches it from App\Livewire\Component.

For environments where an immediate version upgrade is not feasible, administrators can apply a manual hotfix directly to the application source code without disrupting active services. First, edit app/Livewire/Component.php to remove HasConfirmation from the trait import and use statement inside the class body. Second, delete the file app/Livewire/Traits/HasConfirmation.php from the filesystem.

# Verify if the instance contains the vulnerable trait
grep -rn "HasConfirmation" app/Livewire/
 
# After removing the trait from app/Livewire/Component.php, remove the trait file
rm -f app/Livewire/Traits/HasConfirmation.php
 
# Clear Laravel cached views and optimized class maps
php artisan optimize:clear

From a defensive monitoring and detection standpoint, because HasConfirmation was an unused feature in legitimate Paymenter workflows, any HTTP request referencing executeConfirmedAction is anomalous and indicative of an exploitation attempt. Security teams should deploy Web Application Firewall (WAF) rules to inspect POST requests targeting /livewire/update and block payloads matching the pattern "method"\s*:\s*"executeConfirmedAction". Existing web server and application logs should also be audited for historical requests to /livewire/update where unexpected pricing modifications or unauthorized account changes occurred.

Official Patches

PaymenterUpstream Git Commit Patch removing HasConfirmation
PaymenterPaymenter v1.5.7 Release Tag
PaymenterOfficial GitHub Security Advisory (GHSA-prhx-9q2h-ph2x)

Fix Analysis (1)

Technical Appendix

CVSS Score
8.1/ 10
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N
EPSS Probability
0.36%
Top 69% most exploited

Affected Systems

Paymenter < 1.5.7

Affected Versions Detail

Product
Affected Versions
Fixed Version
Paymenter
Paymenter
< 1.5.71.5.7
AttributeDetail
Vulnerability IDCVE-2026-103026 / GHSA-prhx-9q2h-ph2x
Weakness ClassCWE-470 / CWE-749 / CWE-915
Attack VectorNetwork (Livewire RPC /livewire/update)
CVSS v3.1 Score8.1 High (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N)
EPSS Score0.36% (31st Percentile)
Primary ImpactBypass of #[Locked] Properties & Arbitrary Method Execution
Fixed VersionPaymenter 1.5.7
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1059Command and Scripting Interpreter
Execution
T1068Exploitation for Privilege Escalation
Privilege Escalation
T1211Exploitation for Defense Evasion
Defense Evasion
T1565.001Data Manipulation: Stored Data Manipulation
Impact
CWE-470
Use of Externally-Controlled Input to Select Classes or Code

The application uses external input with reflection or dynamic method dispatch to select which classes or code to execute, allowing attackers to invoke unintended methods or alter application control flow.

Vulnerability Timeline

Vulnerability remediated in upstream commit e0c04af1707a65d8fb91879883aa7eae3292cedc
2026-07-25
GitHub Security Advisory GHSA-prhx-9q2h-ph2x and CVE-2026-103026 published
2026-11-19
NVD analysis and CVSS v3.1 scoring completed
2026-11-19
EPSS score calculated and updated
2026-11-20

References & Sources

  • [1]GitHub Security Advisory: GHSA-prhx-9q2h-ph2x
  • [2]Upstream Fix Commit e0c04af1707a65d8fb91879883aa7eae3292cedc
  • [3]Raw Git Patch for CVE-2026-103026
  • [4]Paymenter Release v1.5.7
  • [5]CVE.org Record: CVE-2026-103026
  • [6]National Vulnerability Database (NVD): CVE-2026-103026

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

•about 2 hours ago•CVE-2026-104885
6.3

CVE-2026-104885: Cross-Realm MQTT Session Disconnect via Missing Authorization in OpenRemote

OpenRemote prior to version 1.31.0 contains a Missing Authorization vulnerability (CWE-862) in the user management REST API endpoint responsible for disconnecting active MQTT sessions. The disconnectUserSession method in UserResourceImpl fails to verify whether the requesting user owns the target MQTT session, holds administrative privileges, or belongs to the realm specified in the request path. As a result, any authenticated user who obtains a valid MQTT session identifier can forcefully terminate active MQTT connections belonging to other users or IoT devices across any tenant realm.

Amit Schendel
Amit Schendel
2 views•9 min read
•about 3 hours ago•CVE-2026-69133
5.3

CVE-2026-69133: Cumulation Buffer Memory Retention in Netty OHTTP Codec

CVE-2026-69133 (GHSA-cg26-4c6j-2x8h) is a missing resource release vulnerability (CWE-772) in io.netty.incubator:netty-incubator-codec-ohttp affecting versions 0.0.20.Final through 0.0.26.Final. Both OHttpClientCodec and OHttpServerCodec retain the outer cumulationBuffer at its expanded high-water capacity after an Oblivious HTTP (OHTTP) exchange finishes. A remote unauthenticated attacker can complete a large OHTTP request or response over an HTTP keep-alive connection and leave the connection idle, pinning pooled or direct memory allocations across concurrent connections to induce denial of service.

Amit Schendel
Amit Schendel
2 views•8 min read
•about 4 hours ago•CVE-2026-104773
6.8

CVE-2026-104773: Session Fixation in CKAN User Registration View

A session fixation vulnerability (CWE-384) exists in CKAN (Comprehensive Knowledge Archive Network) prior to versions 2.10.11 and 2.11.6. When configured with server-side session storage and active public web registration, the user registration view programmatically authenticates newly created accounts without regenerating the active session identifier. An attacker capable of fixing or capturing a victim's pre-authentication session cookie can hijack the newly registered account immediately after registration completes.

Alon Barad
Alon Barad
2 views•9 min read
•about 5 hours ago•CVE-2026-35374
6.3

CVE-2026-35374: Arbitrary File Truncation via TOCTOU Race Condition in uutils coreutils split

CVE-2026-35374 is a Time-of-Check to Time-of-Use (TOCTOU) race condition (CWE-367) in the split utility of uutils coreutils. The utility validates that the input and output paths do not refer to the same file before opening the output file with truncation flags. A local attacker with write permissions in the destination directory can replace the output file path with a symbolic link during this race window, causing the process to truncate and overwrite arbitrary files accessible to the user executing split.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 6 hours ago•CVE-2026-35377
3.3

CVE-2026-35377: Local Denial of Service via Improper Single-Quote Backslash Parsing in uutils coreutils env

CVE-2026-35377 is an improper input validation vulnerability (CWE-20) in the env utility of uutils coreutils, the Rust-based reimplementation of GNU coreutils. When processing command-line arguments with the -S (--split-string) option, the uutils split-string tokenizer erroneously validates backslash sequences enclosed within single quotes against a fixed table of known escape characters. Under standard GNU env behavior, backslashes inside single quotes are treated literally (except for \\ and \'). Because uutils rejects unrecognized sequences such as \a, \x, or \| with exit code 125, automated scripts, shebang invocations, and administrative workflows relying on POSIX/GNU compatibility fail to execute, resulting in a local denial of service.

Alon Barad
Alon Barad
2 views•9 min read
•about 7 hours ago•CVE-2026-35376
4.5

CVE-2026-35376: Time-of-Check Time-of-Use (TOCTOU) Race Condition in uutils coreutils chcon

A Time-of-Check to Time-of-Use (TOCTOU) race condition in the chcon utility of uutils coreutils prior to version 0.8.0 allows a local attacker with write access to a directory tree undergoing recursive SELinux context relabeling to redirect extended attribute modifications to arbitrary system files.

Amit Schendel
Amit Schendel
2 views•10 min read