Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure authenticated trainer to malicious page
-
DeliveryBrowser auto-GETs trainer-login via <img> tag
-
Exploit?next= redirect chain bypasses SameSite=Lax
-
ExecutionServer calls django_login() without CSRF check
-
ImpactTrainer session rebound to attacker-chosen user
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 an active, authenticated trainer session in wger and that the trainer be socially engineered into loading an attacker-controlled page containing an <img> (or similar subresource) pointing at GET /en/user/<user_pk>/trainer-login. A critical technical precondition is defeating the browser's default SameSite=Lax cookie policy: the advisory shows this is achieved via the view's ?next= handling, where a 302 to /user/login?next=... produces a same-origin redirect hop that reattaches the session cookie. Limiting factors that reduce realistic risk: the victim must hold trainer privileges, user interaction (visiting the page) is mandatory, and the attack depends on the specific redirect-chain bypass rather than a direct cross-origin request - these constraints mean exploitation is targeted, not opportunistic or wormable. Fixed by upgrading to wger 2.6, which adds @require_POST and validates the redirect target. |
| Impact | This is a genuine but moderate-severity CSRF flaw (CWE-352) whose real-world risk is tempered by several limiting factors. The provided CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N, base 5.4) correctly reflects network reach but requires user interaction (a trainer loading a malicious page) and a privileged victim session, keeping impact at Low/Low. No EPSS score was supplied and the CVE is NOT on CISA KEV, so there is no confirmed active exploitation. The advisory contains a Playwright-verified SameSite-Lax bypass description but does not publish a reusable exploit repository, so this is best characterized as 'no public exploit identified' rather than POC-available - the detailed bypass writeup does, however, lower the barrier for an attacker to reproduce it. One notable caveat: the CVSS AC:L understates the real difficulty, since modern browsers default to SameSite=Lax and the attack depends on a specific ?next= same-origin redirect chain to attach the cookie - verify the AC rating against the documented bypass. Net: a legitimate issue worth patching for any wger instance with trainer accounts, but not a drop-everything priority given no KEV, no published POC, the UI:R requirement, and the niche deployment footprint. |
| Exploit ScenarioDerived | An attacker hosts a web page containing <img src="https://wger.target/en/user/2/trainer-login">. When an authenticated wger trainer is lured into visiting that page, their browser auto-issues the GET with the session cookie (chained through a ?next= same-origin redirect to defeat SameSite=Lax), and the server silently rebinds the trainer's session to user account 2. No public exploit package exists, though the advisory documents the technique in enough detail to reproduce. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 07, 2026
wger before 2.6 contains a CSRF bypass (CWE-352) that lets an attacker-controlled web page silently rebind an authenticated trainer's session to an arbitrary user account. Because the trainer_login view (wger/core/views/user.py, ~lines 161-210) accepts GET and calls django_login() directly, it falls outside Django's CsrfViewMiddleware enforcement, which only checks unsafe methods; a single <img> tag pointing at /en/user/<user_pk>/trainer-login forces the victim's browser to issue the request with the session cookie attached. Exploitation is authenticated (CVSS PR:L) and requires user interaction (UI:R) - the trainer must hold trainer privileges and be lured onto the malicious page - and, per the assessed vector, it depends on a non-trivial SameSite=Lax bypass via the view's ?next= 302 redirect chain, which raises attack complexity to AC:H and makes this a targeted rather than opportunistic or wormable issue. No CISA KEV listing or independent public exploit code was identified at time of analysis, though the vendor advisory documents a Playwright-verified reproduction in Chromium 147.
RemediationAI
Upgrade to the vendor-released patch in wger 2.6 (https://github.com/wger-project/wger/releases/tag/2.6), which adds @require_POST to the trainer_login view and validates the redirect target with url_has_allowed_host_and_scheme, moving ?next= handling into the POST body. Be aware that 2.6 is a breaking release: it introduces offline-mode backend changes, social login and 2FA support (all users must re-login), and JWT refresh-token rotation with blacklist-after-rotation - plan a maintenance window and review prod.env settings, particularly REFRESH_TOKEN_LIFETIME, before upgrading. If an immediate upgrade is not possible, the most effective compensating control is to make the endpoint unreachable for GET: front the application with a reverse proxy or WAF rule that rejects GET to /user/*/trainer-login (the trade-off is that any legitimate trainer-switching UI depends on this route, so verify whether that feature is in use before blocking it). A second option is setting SESSION_COOKIE_SAMESITE='Strict' in Django settings, which blocks the cookie from riding along the same-origin redirect hop the advisory relies on; the side effect is that users arriving from an external link may appear logged out until they navigate again, and cross-site SSO/OAuth callback flows can break. A third, narrower mitigation is to disable the trainer-login route in URLconf entirely if the trainer feature is unused on the instance. Note that the assessed attack also requires the victim to hold trainer privileges, so restricting trainer role assignment to trusted accounts reduces the pool of viable targets but does not fix the flaw. Full details and the suggested diff are in the advisory at https://github.com/wger-project/wger/security/advisories/GHSA-xf64-4pmc-h8qf.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in pypi
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The root cause is improper handling of the login state transition in a Django application. Django's CsrfViewMiddleware, by design, only validates CSRF tokens on unsafe HTTP methods (POST, PUT, PATCH, DELETE), so a state-changing view that is reachable via GET is effectively exempt from CSRF enforcement. wger's trainer_login view is exactly that: it performs a privileged action - calling django.contrib.auth.login() with the ModelBackend to swap the active session's user identity - off a plain GET to GET /en/user/<user_pk>/trainer-login, with no @require_POST decorator or request.method guard. The CWE-352 classification captures the state-changing-via-GET pattern precisely. The advisory also highlights a modern browser nuance the attack leans on: SameSite=Lax blocks the initial cross-origin subresource hop (the <img> request), but the view's handling of the ?next= parameter produces a 302 to /user/login?next=..., and the browser follows that same-origin hop with the session cookie attached, ultimately reaching the target action. That redirect-chain dependency - rather than a straightforward cross-site POST - is what makes the exploit technically demanding and is reflected in the independent assessment's AC:H. The affected CPE is cpe:2.3:a:wger-project:wger:*:*:*:*:*:*:*:* (all versions prior to 2.6), and the ecosystem entry records the pip package wger as vulnerable through <= 2.1 with no fixed version tracked in that dataset even though upstream shipped the fix in release 2.6.
Know when Wger 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:C/C:L/I:L/A:N
AC:H because the attack must evade default SameSite=Lax via a specific redirect chain; PR:L and UI:R since a logged-in trainer must load the page; S:C as the auth context is rebound to another account with Low C/I impact.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
wger is a free, open-source workout and fitness manager. Prior to version 2.6, the trainer_login view in wger accepts GET requests and executes django_login() without any CSRF protection, because Django's CsrfViewMiddleware only enforces tokens on unsafe methods (POST/PUT/PATCH/DELETE). An attacker can embed a single <img> tag on a malicious page; when an authenticated trainer loads that page, their browser auto-issues the GET with the session cookie, forcibly rebinding the trainer's session to an arbitrary user account. Version 2.6 fixes the issue.
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.
Improper Restriction of Excessive Authentication Attempts in GitHub repository wger-project/wger prior to 2.2. Rated cri
Cross Site Scripting vulnerability in wger Project wger Workout Manager v.2.2.0a3 allows a remote attacker to gain privi
Cross Site Request Forgery (CSRF) vulnerability in wger Project wger Workout Manager 2.2.0a3 allows a remote attacker to
Wger versions up to 2.4 allow authenticated users to access other users' private nutrition plans through insecure direct
Wger versions up to 2.4 expose all users' repetition configuration data to any authenticated attacker due to missing aut
Uncontrolled resource consumption in wger before 2.5 allows any authenticated user to exhaust server worker threads and
wger is a free, open-source workout and fitness manager. Five routine detail action endpoints check a cache before calli
Account-deactivation privilege escalation in wger before 2.6 lets an authenticated user who holds only the gym_trainer r
Cross-user integrity corruption in wger versions prior to 2.6 allows authenticated attackers to inject arbitrary workout
Incomplete authorization fix in wger through master exposes three user-management views in wger/core/views/user.py to th
Cross-site request forgery in wger's gym password-reset endpoint allows a remote attacker to force an arbitrary member's
Open redirect in wger's trainer_login view allows an attacker to redirect an authenticated trainer's browser to an arbit
EUVD-2026-94331
GHSA-xf64-4pmc-h8qf
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB