Aug 21, 2026·4 min read·11 visits
An administrative routing bypass in Winter CMS allows attackers to execute highly privileged AJAX handlers via standard HTTP GET requests through cross-site request forgery, leading to unauthorized state-changing operations.
Winter CMS contains a routing bypass vulnerability that allows Cross-Site Request Forgery (CSRF) attacks to trigger administrative AJAX handlers. Due to case-insensitivity in PHP's method resolution and an insufficiently strict check in the backend controller system, an attacker can invoke these handler methods through lowercase HTTP GET requests, bypassing default CSRF token validation.
Winter CMS is an open-source, extensible content management system built on the Laravel framework.
The backend panel features an AJAX framework that facilitates asynchronous administrative actions. These actions are handled by specific controller methods, commonly referred to as AJAX handlers, which process administrative request payloads.
A routing mechanism flaw allows authenticated administrative AJAX handlers to be executed through standard HTTP GET requests. This route bypass exposes the application to cross-site request forgery attacks because the GET routing path bypasses the default CSRF protection middleware.
Because administrative users maintain broad permissions over layouts, database operations, and logs, the impact of unauthorized execution remains high.
The underlying vulnerability is located within the request-to-action routing engine of the Winter CMS backend controller class.
In PHP, method names are case-insensitive. When an administrator requests a path like /backend/system/eventlogs/index_onemptylog, the routing system verifies if the action exists in the controller using the actionExists verification method.
Because of PHP's case-insensitive method resolution, the lowercase URL string index_onemptylog successfully matches the mixed-case index_onEmptyLog method defined in the controller class.
Once matched, the framework dispatches the handler as a standard page action. Since standard HTTP GET requests do not trigger CSRF validation, the application processes the request and executes the administrative logic.
The vulnerability is resolved by modifying the verification mechanism in the base controller class to strictly enforce matching casing for URL segments.
The original code relied on PHP's default reflection check, which implicitly ignores case differences. The following patch was introduced to compare the declared case of the method with the requested action name:
// In modules/backend/classes/Controller.php
if ($ownMethod) {
$methodInfo = new \ReflectionMethod($this, $name);
/*
* Only allow lowercase actions. Compare the resolved method name rather than the
* requested one - PHP method names are case-insensitive, so a lowercased URL
* segment would otherwise pass this check and still resolve to the mixed-case
* method (eg. "index_onemptylog" reaching index_onEmptyLog()).
*/
if (strtolower($methodInfo->getName()) !== $methodInfo->getName()) {
return false;
}
$public = $methodInfo->isPublic();
if ($public) {
return true;
}
}Additionally, the framework modified the parser function in BackendController.php to prevent camel-case conversion of dashed URL parameters during normalization:
// In modules/backend/classes/BackendController.php
protected function parseAction($actionName)
{
if (strpos($actionName, '-') !== false) {
return snake_case(camel_case($actionName));
}
return $actionName;
}An attack requires an active administrator session and user interaction with a malicious link or embedded asset.
To perform the attack, an adversary constructs a URL targeting a sensitive AJAX handler, such as index_onEmptyLog inside the EventLogs controller, using its lowercased equivalent: index_onemptylog.
The adversary embeds this target URL within a malicious page or document. When the logged-in administrator visits the page, the browser automatically executes an authenticated GET request.
Because the request uses the GET method, CSRF defense mechanisms are not invoked. The application routes the call to the targeted handler, executing administrative functions without consent.
Successful exploitation allows cross-site request forgery attacks to execute arbitrary, highly privileged operations.
Attackers can achieve unauthorized data modifications such as deleting content management templates, truncating crucial logs, or disabling critical system settings.
The unofficial CVSS version 3.1 score is evaluated at 8.8 (High). This reflects the high impact on integrity and availability, combined with the requirement for user interaction.
Administrators must upgrade Winter CMS installations to version 1.2.14 or later immediately.
To update the dependency via composer, execute composer update wintercms/winter.
Detection of exploitation attempts can be achieved by monitoring web access logs for GET requests containing strings such as index_on or other common handler suffixes.
A Web Application Firewall (WAF) rule can be configured to block GET requests matching known AJAX handler signatures on the backend paths.
| Attribute | Detail |
|---|---|
| CWE ID | CWE-352, CWE-178, CWE-862 |
| Attack Vector | Network (Remote) |
| CVSS v3.1 Score | 8.8 |
| Exploit Status | poc |
| KEV Status | none |
CVE-2026-28385 (GHSA-3gq2-x4qg-p4g6) is a Server-Side Request Forgery (SSRF) vulnerability in Canonical LXD versions 4.12 through 6.9. An authenticated user possessing the can_create_images entitlement can force the LXD daemon to execute arbitrary outbound HTTP and HTTPS requests via the /1.0/images API endpoint. Due to the absence of egress destination validation, an attacker can probe host loopback services, RFC 1918 private network segments, and cloud Instance Metadata Services (IMDS) from the network position of the privileged LXD daemon.
Canonical LXD and LXC Incus contain an arbitrary file write vulnerability (CWE-73 / CWE-59) in the `/1.0/instances/<name>/exec` REST API endpoint. When an instance is unpacked from an image archive, top-level symbolic links are extracted directly onto the host filesystem within the instance storage directory. If a crafted image includes a symbolic link named `exec-output` pointing to an arbitrary host path, invoking the execution endpoint with `record-output: true` causes the privileged host daemon to follow the symlink and write command output files directly to the target host directory. An authenticated attacker with permissions to import images and execute commands can exploit this flaw to write controlled content to sensitive host directories such as `/etc/cron.d`, resulting in arbitrary code execution on the host as `root`.
CVE-2026-48749 (tracked as GHSA-vghh-5rfx-xhq8 for LXD and GHSA-2q3f-q5pq-g8wv for Incus) is a critical container escape vulnerability in the Canonical LXD and Linux Containers Incus system container managers. By importing a specially crafted container image archive containing duplicate tar member headers, an authenticated attacker can replace the instance rootfs directory with a symbolic link pointing to the underlying host root filesystem. When performing file operations on a stopped container, the privileged forkfile helper binary resolves the symbolic link without confinement and chroots directly into the host filesystem, granting arbitrary root-level file read and write access.
GHSA-fmc8-p6q7-75cc (associated with CVE-2026-48755) is a critical argument injection vulnerability in Canonical LXD (github.com/canonical/lxd). The vulnerability occurs during instance and storage volume backup operations when processing the user-supplied compression_algorithm configuration parameter. While LXD validates the primary executable token against an allowlist of supported compression binaries, it fails to sanitize or restrict subsequent tokens parsed via shellquote.Split. These additional arguments are passed directly to exec.Command. An authenticated attacker with privileges to trigger backups can inject command-line flags for utilities like zstd to read staged files from a container filesystem and write them to arbitrary paths on the underlying host filesystem, such as /etc/cron.d/, achieving root-level arbitrary code execution on the host.
A critical path traversal vulnerability caused by improper input validation (CWE-20) exists in the direct image download handler of Canonical LXD and Linux Containers Incus. When an authenticated user requests an image import using the URL source type, the daemon reads the image fingerprint from an untrusted HTTP response header (`Incus-Image-Hash` or `LXD-Image-Hash`) without validating that it conforms to a SHA-256 format. This unvalidated string is concatenated directly into a filesystem path via `filepath.Join` prior to file creation and cryptographic verification, allowing directory traversal sequences to write arbitrary files on the host filesystem as root.
CVE-2026-9639 (GHSA-j93m-3j9p-m5m8) is a null pointer dereference vulnerability in Canonical LXD affecting versions 5.0.0 through 5.21.4 and 6.0 through 6.8. The flaw resides in the (*lxdBackend).CreateCustomVolumeFromBackup method within lxd/storage/backend_lxd.go. An authenticated attacker with the can_create_storage_volumes permission can upload a crafted custom volume backup tarball that omits the expires_at field on a snapshot entry, triggering an unhandled SIGSEGV panic and terminating the LXD daemon.