Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain traffic-size observation position
-
DeliveryInduce victim requests reflecting chosen input
-
ExploitCompare gzip-compressed response lengths
-
ExecutionRecover static CSRF token byte-by-byte
-
PersistSubmit forged request passing csrf_protect
-
ImpactPerform unauthorized state change
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V6 - Authentication Response uniformity
|
| Exploitation Conditions | Exploitation requires all of: (1) the target Mojolicious app uses the built-in CSRF helpers so that the same static per-session token is emitted repeatedly (pre-9.48 behavior); (2) responses carrying the csrf_token field are gzip/deflate-compressed; (3) the same response reflects attacker-controlled input adjacent to the token; and (4) the attacker can observe compressed response lengths and induce many adaptive requests from the victim's authenticated session (an on-path/traffic-observation capability). Limiting factors: if response compression is disabled, if no attacker input is reflected into token-bearing pages, or if the attacker cannot measure response sizes, the oracle collapses and the attack fails. The CVSS UI:N/AC:L rating understates these multi-request, chosen-input, side-channel prerequisites - verify against the actual app's compression and reflection behavior. |
| Impact | Signals are mixed and warrant nuance. The vendor CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N, score 9.1, C:H/I:H) portrays a trivially exploitable network flaw, but this understates the real preconditions: a practical BREACH attack requires HTTP response compression to be enabled, an endpoint that reflects attacker-controlled input into the same compressed response as the token, and an observation position to measure ciphertext lengths across many adaptively chosen requests - conditions that make attack complexity genuinely high and that argue for AC:H and user/traffic interaction rather than AC:L/UI:N. EPSS is low (0.15%, 5th percentile) and there is no KEV listing and no public POC, consistent with a theoretically serious but operationally demanding attack. SSVC flags Automatable:yes and Technical Impact:total, which is why it should not be dismissed. Net: real but conditional priority - patch on a normal cycle, prioritize sooner for internet-facing apps that compress responses and reflect user input near the CSRF field. |
| Exploit ScenarioDerived | An attacker who can observe a victim's TLS-encrypted traffic sizes (e.g., shared network or on-path) lures the victim's authenticated browser into repeatedly requesting a compressed page that both reflects an attacker-chosen string and includes the hidden csrf_token field. By adaptively varying the injected string and watching the compressed response shrink when a guess matches, the attacker recovers the full static token and submits a forged state-changing request that passes csrf_protect. No public POC is identified at time of analysis, but the technique follows the well-documented BREACH methodology and the fixed code confirms the static-token weakness. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 15, 2026
CSRF token disclosure in the Perl Mojolicious web framework (versions 4.59 up to but not including 9.48) allows a network attacker to recover a victim's session CSRF token via a BREACH compression side channel and then bypass csrf_protect validation. Because _csrf_token cached and returned one stable per-session value that _csrf_field embedded in every response, an attacker who could inject reflected input into a gzip-compressed page could iteratively guess the token by observing compressed response lengths. There is no public exploit identified at time of analysis, EPSS is low (0.15%), and it is not in CISA KEV, but SSVC rates technical impact as total and automatable as yes.
RemediationAI
Vendor-released patch: 9.48 - upgrade Mojolicious to 9.48 or later, where CSRF tokens are masked with a fresh random value on every request (commit https://github.com/mojolicious/mojo/commit/01921fbbbbeca2d1397e082d4a647f9b84c24e27.patch). If immediate upgrade is not possible, reduce the BREACH oracle by disabling HTTP response compression (gzip/deflate) on responses that contain the CSRF token, at the cost of increased bandwidth and latency; alternatively ensure attacker-controlled input is never reflected into the same compressed response as the csrf_token field, and consider rate-limiting or length-masking (random padding) on token-bearing pages. Each mitigation has trade-offs: disabling compression hurts performance site-wide, and reflection audits are error-prone, so upgrading to 9.48 is strongly preferred. See the advisory at https://seclists.org/oss-sec/2026/q3/146 and release changes at https://metacpan.org/release/SRI/Mojolicious-9.48/changes.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Mojolicious is a widely used real-time Perl web framework (CPE cpe:2.3:a:sri:mojolicious). The flaw is a CWE-204 (Observable Response Discrepancy) instance realized as a BREACH-class oracle. BREACH exploits HTTP-level compression (gzip/deflate): when a secret and attacker-controlled input coexist in the same compressed response, the compressor deduplicates matching byte sequences, so a correct partial guess shrinks the compressed length. The pre-fix _csrf_token helper generated one token per session (unpack "H*", random_bytes(20)) and returned that identical 40-hex value on every call, and _csrf_field placed it in a hidden csrf_token input - giving the oracle a stable target to converge on character by character. The vendor fix (commit 01921fb, released in 9.48) masks the token with a fresh random 20-byte value on every request, emitting an 80-hex string (mask concatenated with mask XOR token) that changes each response while still unmasking to the same session token during validation via secure_compare.
Know when Mojolicious gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
Sources disagree (Medium–Critical)AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N
BREACH needs compression plus reflected input and a traffic-size oracle over many victim-driven requests (AC:H, UI:R); impact is CSRF bypass (I:H) with only token disclosure (C:L).
AV:N/AC:H/PR:N/UI:R/S:U/C:L/I:H/A:N
vuln.today treats the vendor’s rating as authoritative. A higher third-party CVSS (e.g. CISA-ADP) is shown for transparency but does not drive the headline severity.
CVSS VectorVendor: CPANSec
Lifecycle Timeline
3DescriptionCVE.org
Mojolicious versions from 4.59 before 9.48 for Perl expose a stable representation of the session CSRF token to a BREACH compression oracle.
_csrf_token generates and caches one token per session and returns the same value on every call, and _csrf_field places that value in a hidden csrf_token input. When a response carrying the token also echoes attacker-controlled input and is gzip-compressed, the chosen values and the resulting compressed lengths form a BREACH oracle.
An attacker able to query it can recover the token and pass csrf_protect validation.
Executive ViewAI
Perl Mojolicious web framework versions 4.59-9.47 contain a critical vulnerability (CVSS 9.1) that allows attackers to hijack user sessions by bypassing CSRF token protections through a compression-based side-channel technique. Although no active exploitation has been detected, this vulnerability affects any organization using vulnerable Mojolicious versions and requires urgent remediation to prevent session compromise and unauthorized account access.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Cross-Site Request Forgery exploits the automatic credential inclusion behavior of web browsers.
More in Mojolicious
View allMojolicious versions from 0.999922 for Perl uses a hard coded string, or the application's class name, as an HMAC sessio
Mojolicious versions from 7.28 for Perl will generate weak HMAC session cookie secrets via "mojo generate app" by defaul
CSRF session hijacking in Mojolicious::Plugin::Web::Auth::OAuth2 through version 0.17 for Perl stems from a predictable
Predictable session ID generation in Mojolicious::Sessions::Storable through version 0.05 for Perl exposes applications
Same weakness CWE-204 – Observable Response Discrepancy
View allVendor StatusVendor
SUSE
Severity: Moderate| Product | Status |
|---|---|
| openSUSE Tumbleweed | Fixed |
| SUSE Linux Enterprise Module for Package Hub 15 SP7 | Affected |
EUVD-2026-44067
GHSA-6cg9-7rr8-cvj2
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB