CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-48500

CVE-2026-48500: Unauthenticated File Upload and Resource Exhaustion in Filament Admins

Alon Barad
Alon Barad
Software Engineer

Jun 24, 2026·7 min read·188 visits

Executive Summary (TL;DR)

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.

Vulnerability Overview

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).

Root Cause Analysis

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.

Code-Level Analysis

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.

Attack Methodology and Exploit Mechanics

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.

Security Impact and Threat Modeling

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 and Long-term Prevention

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/filament

If 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.

Official Patches

filamentphpOfficial vendor advisory and release notes

Fix Analysis (3)

Technical Appendix

CVSS Score
6.5/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:L
EPSS Probability
0.21%
Top 89% most exploited

Affected Systems

Filament Admin Panels for Laravel (filament/filament)

Affected Versions Detail

Product
Affected Versions
Fixed Version
filament/filament
filamentphp
>= 3.0.0, < 3.3.523.3.52
filament/filament
filamentphp
>= 4.0.0, < 4.11.54.11.5
filament/filament
filamentphp
>= 5.0.0, < 5.6.55.6.5
AttributeDetail
CWE IDCWE-862
Attack VectorNetwork (AV:N)
CVSS v3.1 Score6.5
EPSS Score0.00207 (10.69th percentile)
ImpactStorage depletion, Denial of Service (DoS)
Exploit StatusPoC / Conceptual
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1068Exploitation for Privilege Escalation
Privilege Escalation
T1496Resource Hijacking
Impact
T1498Network Denial of Service
Impact
CWE-862
Missing Authorization

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.

References & Sources

  • [1]GitHub Security Advisory GHSA-44wp-g8f4-f4v5
  • [2]CVE-2026-48500 Authority Record

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•10 minutes ago•CVE-2026-118748
7.5

CVE-2026-118748: Unbounded Memory Allocation Denial of Service in ASP.NET Core Blazor Static-SSR

CVE-2026-118748 is a remote Denial of Service (DoS) vulnerability in Microsoft ASP.NET Core (.NET 11.0 preview releases prior to 11.0.0) and Microsoft Visual Studio 2026 (prior to 18.12.0). The flaw originates from unbounded resource allocation (CWE-770) within the Blazor static server-side rendering (static-SSR) validation pipeline, where dynamic or attacker-supplied form field identifiers are cached in a singleton-scoped memory structure without size limits or eviction policies. Unauthenticated remote attackers can exploit this condition over the network by sending repeated HTTP requests with unique field names, exhausting heap memory and terminating the host process via an unhandled OutOfMemoryException.

Alon Barad
Alon Barad
0 views•9 min read
•about 1 hour ago•CVE-2026-114150
5.9

CVE-2026-114150: Remote Information Disclosure via Uninitialized Pooled Memory in ASP.NET Core Response Buffering

CVE-2026-114150 is a network-accessible information disclosure vulnerability affecting Microsoft ASP.NET Core in .NET 11.0 preview releases and Microsoft Visual Studio 2026 prior to version 18.12.0. The flaw stems from the use of uninitialized resources (CWE-908) within response buffering components, specifically ResponseBufferingStream used by middleware such as HTTP Logging and Output Caching. Because rented memory segments from ArrayPool<byte> or MemoryPool<byte> are not cleared upon return or strictly bounded to the exact written byte count during subsequent reads, residual response payloads from earlier HTTP requests remain in the buffer tail. Downstream consumers or log sinks reading these buffers expose confidential cross-session data, including authentication tokens and personally identifiable information.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 2 hours ago•CVE-2026-114146
9.0

CVE-2026-114146: Elevation of Privilege in ASP.NET Core SignalR Connection Dispatcher

An incorrect authorization vulnerability (CWE-863) exists in the ASP.NET Core SignalR HTTP Connection Dispatcher (`Microsoft.AspNetCore.Http.Connections`). The connection negotiation process failed to bind the authenticated caller identity to the generated connection state, and subsequent transport or message dispatch handlers failed to verify caller consistency. Consequently, an authenticated low-privilege attacker who obtains a valid connection identifier or token can inject messages into or hijack another user's SignalR session, achieving an elevation of privilege across security boundaries.

Alon Barad
Alon Barad
4 views•11 min read
•about 3 hours ago•CVE-2026-109478
7.5

CVE-2026-109478: Algorithmic Complexity Denial of Service in ASP.NET Core Header Parsing

CVE-2026-109478 is a network-accessible Denial of Service (DoS) vulnerability in ASP.NET Core caused by inefficient algorithmic complexity (CWE-407) when parsing comma-separated HTTP request headers. Prior to the patch, the internal helper method ParsingHelpers.GetHeaderSplit repeatedly called StringValues.Concat inside a loop iterating over each comma-separated token. Because StringValues allocates a new array of size k + 1 and copies all existing elements upon each concatenation, processing N tokens incurs O(N^2) time and space complexity. An unauthenticated remote attacker can send HTTP requests with headers containing thousands of short, comma-separated values to exhaust CPU cycles and induce severe Garbage Collection (GC) pauses, rendering the web application unresponsive.

Alon Barad
Alon Barad
6 views•11 min read
•about 4 hours ago•CVE-2026-114147
7.5

CVE-2026-114147: Denial of Service via Memory Leak in ASP.NET Core SignalR Redis Backplane

CVE-2026-114147 is a high-severity Denial of Service (DoS) vulnerability affecting ASP.NET Core and specifically the Microsoft.AspNetCore.SignalR.StackExchangeRedis scale-out provider across .NET 8.0, 9.0, 10.0, and 11.0 preview releases. The vulnerability originates from a string comparison mismatch between internal per-connection group collections and the centralized Redis channel subscription registry, compounded by a race condition during connection teardown. Remote unauthenticated attackers can exploit this flaw to leave orphaned connection contexts and active Redis pub/sub listeners pinned in memory, leading to unbounded memory exhaustion and application process termination.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 5 hours ago•CVE-2026-114156
6.5

CVE-2026-114156: Path Equivalence Security Feature Bypass in Microsoft ASP.NET Core

CVE-2026-114156 is an improper resolution of path equivalence vulnerability (CWE-41) in Microsoft ASP.NET Core affecting .NET 11.0 preview releases and Microsoft Visual Studio 2026. The vulnerability stems from a discrepancy between how path prefix validation helpers (such as PathString.StartsWithSegments) and downstream routing mechanisms handle alternate path separators and percent-encoded characters. An unauthenticated remote attacker can exploit this mismatch over the network to bypass path-based authorization middleware and access restricted endpoints.

Amit Schendel
Amit Schendel
5 views•8 min read