Aug 6, 2026·6 min read·17 visits
Missing admin authorization check in Craft CMS's GlobalsController allows low-privilege authenticated users to reorder global sets via direct API endpoint calls.
An authorization bypass vulnerability in Craft CMS allows authenticated control panel users with low privileges to reorder global sets. This alters structure and writes to the project configuration database schema without administrative rights.
Craft CMS utilizes "Global Sets" to manage site-wide variables and content modules. These components are handled through the administrative Control Panel (CP) via controllers designed to manage structural operations. The GlobalsController exposed a specific action route, actionReorderSets(), meant exclusively for system administrators to alter the sequential layout and prioritization of these global configurations.
This endpoint resides in the core routing configuration, rendering it accessible via POST requests directed to /actions/globals/reorder-sets or through query parameters like ?p=actions/globals/reorder-sets. However, in vulnerable versions up to 4.18.0.1, the application did not apply corresponding controller-level restriction mechanisms. Any authenticated session with basic CP access could access and invoke the endpoint.
This flaw falls under CWE-285 (Improper Authorization) and CWE-639 (Authorization Bypass Through User-Controlled Key). While standard content management operations are segregated by user roles and specific permissions, this route bypassed administrative boundaries. Consequently, low-privilege users could modify the database and global configuration file sequences without proper credentials.
The root cause of CVE-2026-14793 lies in the omission of authorization checks within the execution pipeline of the controller method. Craft CMS controllers typically execute filter chains or explicit security checks before handling request parameters. Administrative controllers utilize the $this->requireAdmin() helper method to enforce that the current user context contains administrative privileges.
In the vulnerable configuration of GlobalsController.php, the action method actionReorderSets only enforced transport-layer constraints. It invoked $this->requirePostRequest() to ensure the request method was HTTP POST and $this->requireAcceptsJson() to enforce JSON transport format. However, it failed to perform user-level validation, allowing any authenticated session to reach the underlying service call.
Furthermore, the service layer function Craft::$app->getGlobals()->reorderSets() operates under the assumption that the calling context has already performed necessary authorization validation. This architectural pattern delegates boundary enforcement entirely to the controller layer. When a controller action fails to invoke $this->requireAdmin(), the underlying database operations run without validation, resulting in structural state updates.
Analysis of the vulnerable source code highlights the security gap in src/controllers/GlobalsController.php (commit f801317b13e4a87d704a50a2807a0af83325c452). The method lacked any checks validating the active user's permissions, directly invoking parameter extraction and service layer execution immediately after confirming transport validation.
// VULNERABLE CODE (<= 4.18.0.1)
public function actionReorderSets(): Response
{
$this->requirePostRequest();
$this->requireAcceptsJson();
// Missing authorization check here
$setIds = Json::decode($this->request->getRequiredBodyParam('ids'));
Craft::$app->getGlobals()->reorderSets($setIds);
}The function decodes the array of IDs sent in the request parameter ids and directly processes the update database sequence. Since there is no controller gate, the PHP pipeline proceeds blindly to the persistence layer.
// PATCHED CODE (>= 4.18.1 / 5.10.3)
public function actionReorderSets(): Response
{
$this->requirePostRequest();
$this->requireAcceptsJson();
$this->requireAdmin(); // Enforces administrative context before execution
$setIds = Json::decode($this->request->getRequiredBodyParam('ids'));
Craft::$app->getGlobals()->reorderSets($setIds);
}The integration of $this->requireAdmin() successfully forces execution flow verification against Yii2 session properties. If the user session lacks the active administrative flag, the application halts execution and outputs a 403 Forbidden JSON error block, neutralizing the bypass vector.
To exploit this vulnerability, an attacker must first obtain a valid, authenticated Control Panel session. This prerequisite restricts the attack surface to registered users, such as low-privileged editors, translators, or guest authors. Once logged in, the attacker can leverage the browser session's cookies and retrieve the current application-wide CSRF token from the Control Panel's DOM.
The attacker then crafts a direct POST request targeted at /index.php?p=actions/globals/reorder-sets. The request payload requires the parameter ids set to a JSON-formatted string array of integers representing the desired configuration order. This can be submitted either via standard application/x-www-form-urlencoded form encoding or application/json headers, containing the appropriate cookie and CSRF header.
POST /index.php?p=actions/globals/reorder-sets HTTP/1.1
Host: target-craftcms.local
User-Agent: Mozilla/5.0 (Security-Researcher)
Accept: application/json
Content-Type: application/json
Cookie: CraftSessionId=8abc01df823de7e123654;
X-CSRF-Token: your_csrf_token_here
Connection: close
{
"ids": "[3,2,1]"
}Upon processing, the backend decodes the requested layout sequence and modifies the database records. In environments where Craft CMS tracks configuration changes in files (Project Config), this action additionally writes state changes directly to the project configuration directory. These configuration modifications are then tracked by version control, potentially introducing persistence anomalies across deployments.
The direct impact of CVE-2026-14793 is categorized as partial loss of integrity. Because an unauthorized user can modify the sequential positioning of global content sets, the presentation layer of the public website may become distorted or unreadable. While this does not immediately allow remote code execution, manipulating application-wide variables can lead to secondary injection vectors if downstream template files process global attributes insecurely.
Additionally, Craft CMS utilizes a Project Config system to store structure and configuration in YAML files. The execution of the unauthorized global reordering triggers a serialization process that updates these configuration files on the local filesystem. In automated continuous integration pipelines, this modification could be committed to git, leading to configuration drift or pipeline failures.
Based on the CVSS v4.0 metrics, this vulnerability has a base score of 5.3 (CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N). The vulnerability requires basic user credentials (PR:L) but is executable remotely over the network with low complexity. This highlights the risk of privilege escalation within corporate content-management networks.
The primary remediation is to upgrade Craft CMS to version 4.18.1 (for 4.x installations) or 5.10.3 (for 5.x installations). These versions integrate the necessary role restriction check into the controller, securing the execution path. Organizations must apply the updates using Composer or the official Control Panel updater to ensure the patch is compiled into the codebase.
For environments where an immediate software upgrade is not feasible, administrators should audit and restrict Control Panel access. Disabling access to the Control Panel for all non-administrative users provides an effective temporary mitigation. Alternatively, custom access policies or Web Application Firewalls (WAF) can block requests targeting the specific URI path /actions/globals/reorder-sets for non-admin IP blocks.
This flaw underscores the importance of a defense-in-depth model in modern software architectures. Developers should implement security checks at both the controller boundary and the service layer. Relying solely on controllers to gate administrative functions introduces single points of failure, where an omitted helper call exposes the entire database layer to unauthorized manipulation.
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N| Product | Affected Versions | Fixed Version |
|---|---|---|
Craft CMS Craft | <= 4.18.0.1 | 4.18.1 |
Craft CMS Craft | 5.x < 5.10.3 | 5.10.3 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-285 |
| Attack Vector | Network |
| CVSS v4.0 | 5.3 (Medium) |
| EPSS Score | 0.00224 (Percentile: 13.08%) |
| Impact | Partial Integrity Modification |
| Exploit Status | Proof of Concept |
| KEV Status | Not Listed |
The software does not perform or incorrectly performs an authorization check when an actor attempts to access a resource or perform an action.
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.