Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate as low-privileged user
-
DeliverySend PATCH to user update route with admin's identifier
-
ExploitBypass isWorkflow() authorization check
-
ExecutionOverwrite target email and password
-
ImpactTake over administrator account
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Authorization logic validation
MITRE ATT&CK
1 technique across 1 tactic: Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires a valid, authenticated LavaLite CMS account with low privileges (PR:L) - the attacker must be able to log in before exploiting. The specific trigger is a PATCH request to the user update API route carrying a target user identifier other than the attacker's own; the flaw lies in the AbstractRequest isWorkflow() authorization check (src/Litepie/Http/Request/AbstractRequest.php) and the user.php workflow config failing to restrict which records a caller may modify. No user interaction from the victim is needed and the default configuration appears affected. The primary limiting factor is the authentication requirement - fully unauthenticated attackers cannot exploit this - which, combined with the product's niche deployment, narrows realistic exposure to environments that permit low-trust user registration or where an attacker has already obtained low-level credentials. |
| Impact | This is a genuine but moderate-priority issue rather than an overhyped high-CVSS finding. The supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:H/VA:N) and the description align well: network-reachable, low attack complexity, but requiring an existing low-privileged authenticated account (PR:L) and delivering an integrity-only impact (the ability to overwrite other users' name, email, password, status, or mobile). The base score of 7.1 is driven almost entirely by VI:H, since changing an administrator's password or email is effectively an account-takeover primitive. No EPSS score, CISA KEV listing, or public POC is present in the provided data, so exploitation probability signals are absent - this appears to be a vendor/researcher-reported flaw (VulnCheck) with no evidence of in-the-wild use. The one notable nuance: the official vector rates confidentiality and availability as N, but in practice resetting an admin's credentials can cascade into full control of the CMS, so real-world impact may exceed the integrity-only scoring - verify against the fix in LavaLite cms issue #431. Overall: real and worth patching because the privilege barrier is low and the integrity impact is severe, but the requirement for a valid authenticated account and the niche deployment footprint keep it below the tier of an unauthenticated internet-wide threat. |
| Exploit ScenarioDerived | An attacker registers or already holds a low-privileged LavaLite CMS account, then sends a crafted PATCH request to the user update API route supplying another user's identifier - for example an administrator's. Because the AbstractRequest isWorkflow() check fails to enforce ownership/authorization, the server applies the changes, letting the attacker rewrite the admin's email and password and seize the account. No public exploit code is identified at the time of analysis, but the technique is trivial to reproduce from the referenced source lines. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 12, 2026
Authorization bypass in LavaLite CMS through 10.1.2 lets an authenticated low-privileged user modify other users' accounts - including administrator accounts - by sending a PATCH request to the user update route carrying a target user identifier, altering the victim's name, email, password, status, or mobile number. The CVSS:4.0 vector (AV:N/AC:L/PR:L/UI:N/VI:H) and the independent CVSS:3.1 assessment (PR:L, I:H, S:U) both confirm that a valid low-privilege login is required, that no victim interaction or non-default configuration is needed, and that the impact is high-integrity write access with no direct confidentiality or availability loss; the practical effect is a route to full administrative account takeover. No public exploit code was identified at time of analysis and there is no confirmed active exploitation (not in CISA KEV), so the principal exposure limiter remains the need for an existing low-trust account, which narrows realistic risk to deployments that allow self-registration or where an attacker already holds low-level credentials.
RemediationAI
No vendor-released patch identified at time of analysis: the advisory references point only to the vulnerable source (https://github.com/LavaLite/framework/blob/a06cba09da27087b2013035c38c536491e4f83ad/src/Litepie/Http/Request/AbstractRequest.php#L62-L70 and https://github.com/LavaLite/framework/blob/a06cba09da27087b2013035c38c536491e4f83ad/src/Litepie/User/config/user.php#L515), and the upstream issue https://github.com/LavaLite/cms/issues/431 should be tracked for an eventual fix release; monitor https://github.com/LavaLite/cms and the VulnCheck advisory https://www.vulncheck.com/advisories/lavalite-cms-through-10.1.2-authorization-bypass-via-user-update-api for a patched version and upgrade as soon as one is published. Until then, the most direct compensating control is to harden the authorization logic itself: modify the isWorkflow() check in AbstractRequest.php (around lines 62-70) and the workflow definition in user.php (line 515) so that a user-update request is rejected unless the target identifier equals the authenticated user's own ID or the caller holds an administrative role - this is a small, targeted code change, but its trade-off is that it must be re-applied after every upstream upgrade and can break legitimate delegated-administration workflows if the role mapping is not reviewed. Where code changes are not feasible, block or restrict access to the user update endpoint (the PATCH user-update route) at the reverse proxy or WAF so that only trusted administrative source addresses may reach it, accepting that this breaks ordinary self-service profile editing for legitimate users. Additional layered controls: disable or tightly gate self-service user registration and any invitation flows so that untrusted parties cannot obtain the low-privilege account the exploit requires; review existing accounts for unauthorized email, password, status, or mobile changes and force credential resets for any administrator whose record may have been touched; and log/alert on PATCH requests to the user route where the targeted user ID differs from the session's user ID, which does not prevent the attack but supplies reliable detection. Because the issue yields integrity-only impact with no patch currently available, prioritizing the code-level ownership check over broad network blocking will minimize both exposure and operational disruption.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The flaw is a classic incorrect authorization (CWE-863) rather than a memory-safety or injection bug. LavaLite CMS delegates request validation to the Litepie framework, where src/Litepie/Http/Request/AbstractRequest.php (lines 62-70) implements an isWorkflow() check intended to gate which form requests a user may submit and, implicitly, which records and fields those requests may touch; the user workflow configuration in src/Litepie/User/config/user.php (line 515) supplies the field/record definitions that check operates on. Because the authorization logic validates the shape of the workflow request but does not verify that the submitted record identifier belongs to - or is administrable by - the calling user, an attacker who holds any authenticated session can pass a foreign user ID into the PATCH update route and have the framework accept it. The affected package is tracked under the single CPE cpe:2.3:a:lavalite:cms:*:*:*:*:*:*:*:*, with the wildcard version confirming the vendor treats all released versions up to and including 10.1.2 as vulnerable; both the cms application and the bundled framework package are implicated by the referenced source files. This is a record-scoping/idempotency failure in the request-authorization layer, not a missing authentication check - the attacker is legitimately logged in, but the ownership boundary for the update target is never enforced.
Know when Lavalite gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:H/VA:N/SC:N/SI:N/SA:N
Network API reachable with low complexity, but needs an authenticated low-privileged account (PR:L); impact is integrity-only (overwriting other users' data), so C:N/A:N and I:H.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
LavaLite CMS through 10.1.2 contains an authorization bypass vulnerability that allows authenticated low-privileged users to modify other users' accounts by abusing the AbstractRequest isWorkflow() check. Attackers can send a PATCH request to the user update route with a target identifier to change name, email, password, status, or mobile, including for administrators.
Executive ViewAI
LavaLite CMS deployments running version 10.1.2 or earlier are exposed to an account-takeover flaw that allows a low-privilege user to gain control of administrator accounts, directly threatening the integrity and administration of the CMS. This risk is most relevant where self-registration is enabled or low-privilege accounts are broadly issued, and no victim interaction or special configuration is required. Leadership should treat this as a high-priority remediation item until a vendor fix is available, because a successful attack could lead to unauthorized content changes, data manipulation, and further system access.
No vendor-released patch identified at time of analysis. Interim mitigations include disabling self-registration, restricting access to LavaLite CMS administration and user-update routes, enforcing least privilege and removing unnecessary low-privilege accounts, adding WAF/reverse-proxy rules to block cross-account PATCH requests to the user update endpoint, auditing and alerting on account changes, and rotating credentials for privileged accounts. Apply vendor patch when released.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
LavaLite CMS 10.1.0 is vulnerable to Incorrect Access Control. An authenticated user with low-level privileges (User rol
Unauthenticated file disclosure in LavaLite CMS through 10.1.2 allows remote attackers to download private stored files
In Lavalite 9.0.0, the XSRF-TOKEN cookie is vulnerable to path traversal attacks, enabling read access to arbitrary file
Cross Site Scripting vulnerability in Lavalite CMS v.10.1.0 allows attackers to execute arbitrary code and obtain sensit
XSS exists in Lavalite CMS 5.7 via the admin/profile name or designation field. Rated medium severity (CVSS 6.1), this v
LavaLite CMS v 9.0.0 was discovered to be vulnerable to web cache poisoning. Rated critical severity (CVSS 9.8), this vu
LavaLite v9.0.0 is vulnerable to Cross Site Scripting (XSS). Rated medium severity (CVSS 5.4), this vulnerability is rem
LavaLite through 5.7 has XSS via a crafted account name that is mishandled on the Manage Clients screen. Rated medium se
LavaLite 5.5 has XSS via a /edit URI, as demonstrated by client/job/job/Zy8PWBekrJ/edit. Rated medium severity (CVSS 5.4
LavaLite CMS versions up to and including 10.1.0 contain a stored cross-site scripting vulnerability in the package crea
LavaLite CMS v 9.0.0 is vulnerable to Sensitive Data Exposure. Rated high severity (CVSS 7.5), this vulnerability is rem
LavaLite CMS v 9.0.0 is vulnerable to Sensitive Data Exposure. Rated high severity (CVSS 7.5), this vulnerability is rem
EUVD-2026-97358
GHSA-pj48-vpfx-3cj9
NVD
CVE.org
EPSS
Exploit-DB