Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure authenticated backend user to URL
-
DeliveryBrowser sends GET with victim's session
-
ExploitDispatch via key= bypasses token guard
-
ExecutionBackend action executes as victim
-
ImpactDestructive or state-changing effect
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V3 - Web Frontend Security Anti-CSRF tokens, SameSite cookies
MITRE ATT&CK
1 technique across 1 tactic: Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that a Contao backend user be actively authenticated (valid backend session) AND be socially engineered into loading an attacker-controlled URL in that browser - this is the mandatory limiting factor (UI:R). The specific weakness is that RequestTokenListener, the only generic REQUEST_TOKEN validator, runs on POST only, and the declarative GET guard fires solely when an 'act' parameter is present; therefore any backend action dispatched through a different parameter (notably key=) executes over GET with no CSRF token. Executable actions are further LIMITED to the modules/permissions the victim user already holds, and the advisory confirms only destructive/state-changing actions were verified - no privilege escalation. No special non-default configuration is needed; the flaw is in the default dispatch mechanism across all affected versions. |
| Impact | This is a genuinely low-priority issue despite being a 'family' of CSRF bugs. The NVD CVSS of 3.5 (CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:U/C:N/I:L/A:N) correctly reflects weak real-world risk: while the attack vector is network (AV:N) and complexity is low (AC:L), exploitation is gated by two hard preconditions encoded in the vector - the victim must already be an authenticated backend user (PR:L reflects this session dependency) and must actively load an attacker-controlled URL (UI:R). No EPSS score, KEV listing, or public exploit code was provided, so there is no public exploit identified at time of analysis and no evidence of active or automated exploitation. The vendor advisory is notably honest about scope: reachable actions are confined to modules the victim user can already access, and the researchers explicitly state they found NO privilege-escalating action - only destructive or state-changing ones. CONFLICT TO NOTE: the input Tags list 'Privilege Escalation', but the GHSA advisory directly refutes this ('We have not found a key= action that grants privileges'), so that tag appears mislabeled. Net: a real, well-documented CSRF design flaw worth patching on normal cadence, not an emergency. |
| Exploit ScenarioDerived | An attacker crafts a malicious page or link embedding a Contao backend URL that invokes a state-changing action via a non-act dispatch parameter (e.g. key=). A currently-logged-in backend user who visits that URL unknowingly executes the action under their own session with no CSRF token or confirmation. No public exploit code was identified, but the dispatch-level nature of the flaw means any present or future key= action is reachable within the victim's module permissions. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 09, 2026
Cross-site request forgery in Contao CMS's backend action dispatch allows an attacker to make an authenticated backend user silently execute destructive or state-changing backend operations by simply loading an attacker-controlled URL. The flaw exists because RequestTokenListener - the only generic REQUEST_TOKEN validator in Contao - runs on POST requests only, while the GET-side guard is local and declarative and fires solely when an 'act' parameter is present, leaving every backend action dispatched through a different parameter (notably 'key=') with no CSRF protection at all; the CSRF validation added in the fix reads the token from the 'rt' query parameter. The assessed CVSS v3.1 score is only 3.5 (AV:N/AC:L/PR:L/UI:R/S:U/C:N/I:L/A:N) because exploitation requires a valid backend session AND user interaction (the victim must be socially engineered into loading the crafted link), and the reachable actions are limited to modules that victim user can already access - the advisory verified only destructive/state-changing actions, not privilege escalation. Vendor-released patch: 5.3.50 and 5.7.12; no public exploit identified at time of analysis.
RemediationAI
Upgrade composer/contao/core-bundle to 5.3.50 (for the 4.0.0-5.3.x line) or 5.7.12 (for the 5.4.0-RC1 and later line); these are the vendor-released patched versions, and the underlying fix commit is 34dd27ee6739f10568d3d95d8784862255c925b4, with release notes at https://github.com/contao/contao/releases/tag/5.7.12 and the advisory at https://github.com/contao/contao/security/advisories/GHSA-9ff2-p842-45wq. The patch works by forcing the affected DCA operations to POST ('method' => 'POST') and by explicitly validating a Symfony CSRF token supplied as the 'rt' parameter in backend callbacks and in DebugController, throwing InvalidRequestTokenException on failure. If immediate upgrade is not possible, compensating controls must target the GET-without-token path: front the backend with a reverse proxy or WAF rule that rejects GET requests to the Contao backend carrying a 'key=' (or other non-'act') action parameter while unauthenticated tokens are absent - the trade-off is that legitimate backend links using those parameters will break, so test inventory first; enforce a strict SameSite=Lax or Strict cookie policy on the Contao backend session cookie to blunt cross-site browser-initiated GETs, accepting that some cross-site links and embedded workflows may degrade; network-restrict the backend path (e.g., limit /contao to trusted IP ranges or VPN) to shrink the population of users who can be social-engineered into triggering the request; and train backend editors not to open unsolicited Contao links while logged in. Because the root cause is the dispatch mechanism rather than one callback, disabling individual modules offers only partial coverage - patching is the only complete fix, and no vendor-issued patch-absence statement exists, so do not assume a workaround is equivalent to upgrading.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 3 packages in composer, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Contao's backend dispatches actions through request parameters handled in its Data Container Array (DCA) layer; the conventional action parameter is 'act', but many backend callbacks are reachable through a 'key=' parameter or custom parameters instead. CSRF protection is centralized in RequestTokenListener, which validates the Symfony-backed ContaoCsrfTokenManager token (configurable via the '%contao.csrf_token_name%' parameter, conventionally 'rt') - but this listener is registered for POST only. On the GET side, protection is declarative and local to specific callbacks, and it only triggers when an 'act' parameter is present. The result, classified as CWE-352 (Cross-Site Request Forgery), is not a single defective endpoint but a family-level gap in the dispatch mechanism: any present or future 'key=' action inherits the missing-token exposure. The upstream fix demonstrates the intended pattern by (a) requiring POST for affected DCA operations such as the tl_opt_in resend button ('method' => 'POST'), (b) adding explicit 'contao.csrf.token_manager' and CSRF-token-name injection into the manager-bundle controllers and services, and (c) validating a Symfony CsrfToken against Input::get('rt') in callbacks and in DebugController, throwing InvalidRequestTokenException when the token is absent or invalid. CPE data (cpe:2.3:a:contao:contao:*:*:*:*:*:*:*:*) confirms all Contao releases in the affected ranges are in scope, and the underlying PHP package is composer/contao/core-bundle.
Know when Contao 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
AV:N/AC:L/PR:L/UI:R/S:U/C:N/I:L/A:N
CSRF requires an existing authenticated backend session (PR:L) and victim loading the URL (UI:R); low integrity impact from state-changing actions bounded by the victim's module permissions, no confidentiality or availability loss.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
Contao is an Open Source CMS. From version 4.0.0 until 5.3.50 and 5.7.12, RequestTokenListener validates REQUEST_TOKEN only for POST requests, while the declarative GET guard runs only when an act parameter is present. Backend actions dispatched through the key parameter can therefore execute without a CSRF token when an authenticated backend user loads an attacker-controlled URL. Reachable actions remain limited to modules available to that user, and the advisory demonstrates destructive or state-changing actions rather than privilege escalation. This issue is fixed in versions 5.3.50 and 5.7.12.
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.
Contao Managed Edition v1.5.0 was discovered to contain a remote command execution (RCE) vulnerability via the component
Multiple cross-site request forgery (CSRF) vulnerabilities in main.php in Contao (formerly TYPOlight) 2.11.0 and earlier
Contao is a powerful open source CMS that allows you to create professional websites and scalable web applications. Rate
Contao 4.x allows SQL Injection. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitable, no auth
Contao 4.7 allows Use of a Key Past its Expiration Date. Rated critical severity (CVSS 9.8), this vulnerability is remot
Contao before 3.5.39 and 4.x before 4.7.3 has a Weak Password Recovery Mechanism for a Forgotten Password. Rated critica
Contao before 5.5.6 allows XSS via an SVG document. Rated medium severity (CVSS 5.4), this vulnerability is remotely exp
Contao is an open source content management system. Rated medium severity (CVSS 5.4), this vulnerability is remotely exp
Unauthenticated path traversal in the Contao CMS ImagesController lets remote attackers read files from the project dire
Stored cross-site scripting in the Contao CMS comments bundle lets an unauthenticated visitor submit a comment whose ema
Information disclosure in Contao CMS allows unauthenticated front-end visitors to read the titles, URLs, and indexed tex
Unauthenticated email-flooding and user-enumeration in Contao CMS: a POST to any page containing the registration module
EUVD-2026-95979
GHSA-9ff2-p842-45wq
NVD
CVE.org
EPSS
Exploit-DB