Aug 7, 2026·5 min read·13 visits
A mass assignment flaw in Craft CMS's User model allows authenticated users to modify sensitive internal properties, including password and lockout fields, bypassing security controls to achieve full administrator takeover.
A high-severity authorization bypass vulnerability in Craft CMS allows authenticated users to reset arbitrary user passwords, including administrator accounts, by exploiting a mass assignment vulnerability in the User element model.
Craft CMS uses an element-based design where users, entries, assets, and other content types are modeled as elements. The User element model handles the persistence and manipulation of user accounts, including profiles, authentication parameters, and account states.
During a profile update or user save action, parameters provided via incoming HTTP requests are dynamically bound to the corresponding properties of the underlying User model. This process, known as mass assignment, simplifies model population but introduces significant security risks if user-controlled input is not strictly regulated.
This vulnerability, tracked as GHSA-P8X7-9VFW-P7VC, is a high-severity mass assignment issue (CWE-915) in the User element model. An authenticated user with permission to modify their profile or submit user data can manipulate internal attributes of other accounts or their own account.
This bypasses the typical security verification flows, leading directly to password resets on arbitrary accounts and potential full administrator takeover.
The root cause of this vulnerability lies in the insufficient input filtering within the setAttributesFromRequest method of the User element model located in src/elements/User.php.
When a request to update user details is received, Craft CMS calls setAttributesFromRequest($values) to process raw HTTP parameters before binding them to the model. In the vulnerable version, the method only unset a single parameter, unverifiedEmail, from the input array.
Because the underlying Yii2 framework dynamically maps request inputs to safe model attributes, an attacker could supply other highly sensitive model properties. Since attributes like password, newPassword, lockoutDate, and invalidLoginCount were not explicitly stripped from the $values array, the framework bound them to the User model.
Consequently, when the model was subsequently saved, these values were committed to the database. This allows an attacker to reset credentials or modify security states directly, completely avoiding specialized controllers designed to validate password changes, token lifetimes, or previous passwords.
An inspection of the vulnerable implementation in src/elements/User.php highlights how the mass assignment vulnerability occurred. The system relied on a highly permissive binding model:
// Vulnerable Implementation
public function setAttributesFromRequest($values): void
{
unset($values['unverifiedEmail']);
if (isset($values['email'])) {
$values['email'] = trim($values['email']);
}
// ... continues to bind attributes ...
}In this code path, only unverifiedEmail is explicitly protected from bulk assignment. If a malicious payload containing parameters such as password or lockoutDate was submitted, those keys remained in the $values array and were updated on the user record.
To remediate this, the developer introduced a comprehensive denylist in the patch. The updated setAttributesFromRequest method now unsets all variables tied to credential storage, lockout history, and session validation:
// Patched Implementation
public function setAttributesFromRequest($values): void
{
unset(
$values['invalidLoginCount'],
$values['lastInvalidLoginDate'],
$values['lastLoginAttemptIp'],
$values['lastLoginDate'],
$values['lastPasswordChangeDate'],
$values['lockoutDate'],
$values['newPassword'],
$values['password'],
$values['unverifiedEmail'],
$values['verificationCodeIssuedDate'],
);
if (isset($values['email'])) {
$values['email'] = trim($values['email']);
}
// ... remaining logic ...
}This explicit unset process prevents input parameters representing sensitive attributes from reaching the active record binder, effectively neutralizing the mass-assignment attack vector.
To exploit this vulnerability, an attacker requires an active authenticated session with the ability to submit profile updates or trigger the saving of user elements. This vulnerability does not require administrative privileges to initiate.
The attacker crafts a multipart form-data or JSON payload directed toward the user save endpoint, typically users/save-user or a custom frontend profile update route. Along with the standard profile parameters, the attacker includes malicious inputs targeting sensitive properties.
For example, appending parameters such as password or newPassword with a chosen string causes the backend to update the target account credentials directly. Alternatively, an attacker whose account is locked or restricted could supply parameters like lockoutDate with a null value or invalidLoginCount with zero to bypass brute-force protection mechanisms.
Because the database write operation occurs during the element save process, the target account password is set to the attacker's value immediately. No email verification or token exchange is triggered, allowing seamless account takeover.
The security impact of this vulnerability is classified as high. By targeting the password and credential attributes of other users, an attacker can execute arbitrary user password resets.
If the target is an administrator, the attacker gains full control over the Craft CMS instance. Administrative access to the Craft CMS control panel allows arbitrary PHP code execution through template customization, plugin installation, or system configuration modifications.
Furthermore, the ability to reset security counters like invalidLoginCount and lockoutDate undermines defense-in-depth measures against automated brute-force attacks. This vulnerability allows actors to hide their activities and persist on compromised systems by resetting authentication-related dates.
The CVSS score is estimated at 8.8 (High) under CVSS v3.1, assuming a registered network attacker exploiting low privileges (PR:L) to perform a direct compromise of high-integrity administrative assets (UI:N, S:U, C:H, I:H, A:H).
The primary remediation step is upgrading to Craft CMS version 5.10.8 or later. This release incorporates the security fix that discards sensitive attributes from dynamic request payloads.
If upgrading is delayed, developers should review custom controllers that bind HTTP request data directly to user models. Avoid generic dynamic loading methods like $model->load($_POST) or $model->setAttributes() unless strict allowlists are enforced through Yii2 scenarios or validated parameter sets.
Detection of exploitation attempts can be achieved by monitoring web application firewalls (WAF) or application logs for requests targeting user-save controllers. Payloads containing unexpected parameters such as newPassword, lockoutDate, or invalidLoginCount in non-password-reset contexts represent strong indicators of compromise.
Additionally, audit the application database for anomalous modifications of the lastPasswordChangeDate or unexpected resets of invalidLoginCount that are not accompanied by expected password reset workflows.
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H| Attribute | Detail |
|---|---|
| CWE ID | CWE-915 |
| Attack Vector | Network |
| CVSS v3.1 Score | 8.8 |
| Exploit Status | none |
| KEV Status | not listed |
NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.
CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.
CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.
CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.
A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.
CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.