Sep 2, 2026·7 min read·24 visits
Filament's TOTP verification allowed the replay of older valid codes within the drift window because it tracked used codes individually rather than globally tracking the last accepted timestep. This allowed an attacker with compromised passwords to bypass multi-factor authentication.
A multi-factor authentication bypass vulnerability exists in Filament (Laravel full-stack framework panels) due to improper time-step tracking of Time-Based One-Time Password (TOTP) codes. By submitting valid TOTP codes from an older time window within the drift allowance, an attacker with a user's password can bypass the single-use MFA guarantee and obtain unauthorized account access.
Filament is an administrative panel and full-stack rapid development framework built on top of Laravel. Within its core architecture, Filament provides built-in support for Multi-Factor Authentication (MFA), including Time-Based One-Time Passwords (TOTP) conforming to RFC 6238. This capability is used to secure high-privilege access to admin panels and backend management consoles, exposing an administrative attack surface to malicious actors.
A vulnerability designated as CVE-2026-84306 (GHSA-r3j6-gpjw-qfjr) was identified in the MFA verification logic of Filament. The software failed to enforce strict monotonic progression of the TOTP time-steps. As a result, older, unused TOTP codes within the accepted time-drift window could be successfully replayed even after a newer TOTP code had already been verified and processed.
This flaw belongs to the class of CWE-294 (Authentication Bypass by Capture-replay). By exploiting this vulnerability, an attacker who has already acquired a target user's primary credentials can bypass the secondary MFA challenge, gaining unauthorized administrative access to the application panel.
The security flaw resides in the packages/panels/src/Auth/MultiFactor/App/AppAuthentication.php component, specifically within the verifyCode method. According to the RFC 6238 specifications, once a TOTP code corresponding to a specific timestep is verified and accepted, the server must invalidate that entire timestep and all previous timesteps. This behavior ensures that the authentication state progresses strictly forward, preventing the validation of any older codes, even if those codes still fall within the configured clock drift window (typically around 4 minutes to accommodate network latency and client desynchronization).
In vulnerable versions of Filament, the code-tracking mechanism maintained state on a per-code basis rather than a per-secret basis. The application generated a unique cache key for each verification attempt using the following schema:
$cacheKey = 'filament.app_authentication_codes.' . md5($secret . $code);Because the cache key incorporated both the user's multi-factor secret and the specific 6-digit verification code string submitted, each unique code generated its own distinct cache entry. While a user could not reuse the exact same 6-digit code within its active validity lifespan, the server treated any other valid code from a different timestep within the allowed clock drift window as entirely separate and untracked. Consequently, if a user logged in with a code from timestep T, an attacker possessing an unused code from timestep T-1 could submit it, bypass the tracking check, and successfully authenticate.
Analyzing the patch applied to packages/panels/src/Auth/MultiFactor/App/AppAuthentication.php reveals how the flaw was remedied. The tracking mechanism was modified to monitor the timestamp of the last validated code globally for each secret rather than monitoring individual 6-digit code strings.
Before the patch, the verifyCode method tracked code reuse by incorporating the submitted code into the MD5 hash:
$cacheKey = 'filament.app_authentication_codes.' . md5($secret . $code);
$timestamp = $this->google2FA->verifyKeyNewer($secret, $code, cache()->get($cacheKey), $this->getCodeWindow());Because each individual code generated a separate cache key, the underlying library's verifyKeyNewer function compared the current code's timestep against an empty or non-existent cached timestamp, allowing older but still mathematically valid codes to pass verification.
In the patched implementation, the cache key is generated using only the multi-factor secret, ensuring a single centralized record of the last authenticated timestamp per user:
$cacheKey = 'filament.app_authentication_codes.' . md5($secret);
$verifyCode = function () use ($cacheKey, $code, $secret): bool {
// Retrieve the last used timestamp globally for this secret
$timestamp = $this->google2FA->verifyKeyNewer($secret, $code, Cache::get($cacheKey), $this->getCodeWindow());
if ($timestamp === false) {
return false;
}
if ($timestamp === true) {
$timestamp = $this->google2FA->getTimestamp();
}
// Save the timestamp of the verified code back into the cache
Cache::put($cacheKey, $timestamp, ($this->getCodeWindow() + 1) * 60);
return true;
};Additionally, the patch implements a critical optimization using cache locks to block race conditions where an attacker could execute parallel, concurrent verification requests:
if (! (Cache::getStore() instanceof LockProvider)) {
return $verifyCode();
}
return Cache::lock("{$cacheKey}.lock", 10)->block(10, $verifyCode);This implementation ensures that concurrent operations must wait for the preceding validation to commit its state to the cache, eliminating race-condition windows.
An attack targeting this vulnerability is classified as highly complex because it requires a specific set of pre-existing conditions and access rights. An attacker cannot exploit this flaw to compromise an account unless they have already obtained the target user's primary credentials (username and password) and can intercept the TOTP codes transmitted by the legitimate user.
Credential Harvest: The attacker steals the user's login credentials via phishing, malware, or credential stuffing.
TOTP Interception: The attacker intercepts the user's TOTP codes. For example, if the user receives TOTP codes via SMS or email, or if the attacker is in a position to monitor the network interface or local device storage, they can intercept a code from an earlier timestep (e.g., T-1 or T-2) that the user did not use because they had already generated a newer code (timestep T).
MFA Replay: The user authenticates with code T. The server accepts the code and writes a cache entry for that specific code. The attacker then authenticates using the intercepted, older code (T-1).
Bypass Verification: Since the older code T-1 has never been recorded in the cache, the server evaluates it as a valid, unused code because it falls within the acceptable clock drift window. The server grants the attacker full access to the administrative panel.
The security impact of CVE-2026-84306 is marked by the complete breakdown of multi-factor authentication integrity for affected Filament installations. When bypassed, the primary layer of credential protection is rendered ineffective, allowing attackers with compromised user credentials to elevate their privileges to that of the targeted administrative account.
Since Filament is frequently used as an administrative interface for business databases, customer information systems, and core application configurations, an administrative session compromise typically results in high confidentiality and integrity impacts. An attacker could extract database contents, manipulate system configuration parameters, or perform unauthorized actions on behalf of administrative users.
Despite the severity of a successful bypass, the exploitability of this vulnerability is limited by the strict prerequisites. The attacker must already hold valid primary credentials and have active visibility into the user's TOTP sequence within a tight time window of approximately four minutes. This requirement accounts for the CVSS score of 6.5 and the high-complexity classification.
To eliminate the exposure caused by CVE-2026-84306, administrators and developers must upgrade Filament to a patched release. No manual configuration changes to the codebase are required once the upgrade is completed.
Run the following commands in the root directory of the application:
# For v4 installations
composer update filament/filament:^4.12.6
# For v5 installations
composer update filament/filament:^5.7.6To ensure the performance and security of the newly introduced mutex lock mechanism, the application's caching backend must support locking. Cache stores such as file, apc, or database drivers without locking support will fail silently back to non-locking verification, maintaining a small race-condition vulnerability window.
It is strongly advised to deploy a cache backend that supports native distributed locking, such as Redis or Memcached, and ensure that the CACHE_DRIVER environment variable is configured to utilize this backend in production.
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:L/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
Filament FilamentPHP | >= 4.0.0, < 4.12.6 | 4.12.6 |
Filament FilamentPHP | >= 5.0.0, < 5.7.6 | 5.7.6 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-294 |
| Attack Vector | Network |
| CVSS v3.1 Score | 6.5 |
| Exploit Status | None/Unproven |
| CISA KEV Status | Not Listed |
| Vulnerability Type | Authentication Bypass by Capture-replay |
The software receives a one-time password or other authentication credential that was captured from a previous session, and it accepts the replayed credential to establish a new, unauthorized session.
CVE-2026-120792 is a high-severity local information disclosure vulnerability in the Microsoft .NET Aspire CLI (Aspire.Cli) affecting versions 13.5.4 prior to 13.6.5. The flaw stems from the insertion of sensitive information into a shared temporary log file (CWE-532) combined with insecure temporary file creation (CWE-377) within the DeprecatedMcpCommandScanner component. During agent configuration scanning, the CLI unconditionally appends internal workspace paths and the first 200 characters of Model Context Protocol (MCP) agent configuration files to a statically named file in the system temporary directory. On multi-user systems, unprivileged local users can read this file to harvest API keys, authentication tokens, and internal service endpoints.
CVE-2026-114159 is a heap-based buffer overflow vulnerability (CWE-122) in Microsoft.DiaSymReader.Native affecting Microsoft Visual Studio and the .NET Runtime on Windows. An integer truncation error during the parsing of oversized document names in Portable PDB symbol files causes an undersized heap allocation, leading to an out-of-bounds memory write and remote code execution.
CVE-2026-114158 is a high-severity remote code execution vulnerability affecting Microsoft Visual Studio 2026 and multiple supported servicing branches of Microsoft .NET (.NET 8.0, 9.0, 10.0, and 11.0) on Windows. The flaw resides in the native symbol reader library, Microsoft.DiaSymReader.Native, and is triggered when parsing Portable Program Database (PDB) metadata containing malformed EmbeddedSource custom debug information records. By supplying a parent Record Identifier (RID) of zero or an out-of-bounds value, an attacker causes an integer underflow during 1-based to 0-based index conversion, leading to a heap-based buffer overflow and arbitrary code execution within the context of the host developer tool or runtime.
CVE-2026-114151 is a high-severity remote code execution vulnerability affecting Microsoft Visual Studio 2026 and multiple supported versions of the Microsoft .NET runtime on Windows. The flaw resides in the native Debug Information Access (DIA) symbol reader component, Microsoft.DiaSymReader.Native. When parsing Program Database (.pdb) files, the component fails to validate the length of serialized numeric records (specifically LF_DECIMAL structures) before unpacking them into a fixed-size stack buffer. An attacker who convinces a user or automated diagnostic process to load a crafted .pdb file can trigger a stack-based buffer overflow, resulting in arbitrary code execution within the context of the host process.
CVE-2026-105544 is a high-severity local elevation of privilege vulnerability in Microsoft .NET and Microsoft.TestPlatform.CLI. Improper access control on local inter-process communication mechanisms and execution brokers allows an authorized local attacker to cross security boundaries and execute arbitrary code in the context of a higher-privileged user running a test execution cycle.
CVE-2026-114152 is a high-severity remote code execution vulnerability affecting Microsoft Visual Studio 2026 and multiple servicing branches of the Microsoft .NET runtime (.NET 8.0, 9.0, 10.0, and 11.0) on Windows platforms. The vulnerability exists within the native symbol reader library, Microsoft.DiaSymReader.Native, specifically inside the DiaObjectFile::ApplyFixup method during the processing of Common Object File Format (COFF) relocation records. By supplying a malformed object file or Program Database (PDB) symbol file containing out-of-bounds relocation offsets or invalid symbol table indices, an unauthenticated attacker can trigger an untrusted pointer dereference (CWE-822) and a stack-based buffer overflow (CWE-121). Successful exploitation occurs when a victim opens, compiles, or debugs a malicious project or symbol artifact, leading to arbitrary code execution within the security context of the active developer environment or build process.