Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure authenticated victim to attacker page
-
DeliveryBrowser sends credentialed GET to SSE stream URL
-
ExploitLiveView created and mounted as victim
-
ExecutionPOST JSON-as-text/plain to message endpoint
-
ImpactState-changing event handlers fire as victim
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 | Requires djust < 1.0.7 with the SSE transport in use (the affected client→server POST endpoints are @csrf_exempt and the GET stream endpoint lacks an Origin check). The victim must have an active cookie-authenticated djust session AND must be lured to visit an attacker-controlled page (UI:R). Exploitation leverages that the URL session_id is client-chosen and validated only for UUID format (not a CSRF token) and that a JSON body sent as Content-Type: text/plain is a CORS simple request needing no preflight. Limiting factors: no attacker authentication needed, but success depends on victim interaction, an existing authenticated victim session, and the SSE transport being enabled and not fronted by an Origin-enforcing proxy. Fully mitigated in 1.0.7 (Origin validated against ALLOWED_HOSTS → 403; POST requires Content-Type: application/json → 415). |
| Impact | This is a genuine, well-characterized CSRF (CWE-352) on djust's Server-Sent-Events transport. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:N = 8.1) is internally consistent for a CSRF: network vector, low complexity, no attacker privileges (the attack rides the victim's cookie session), but requiring user interaction (UI:R) because the victim must be lured to an attacker-controlled page. No EPSS score, no CISA KEV listing, and no public POC are present in the intelligence, so exploitation status is 'no public exploit identified at time of analysis' - this is a disclosed-and-patched advisory, not an actively-exploited threat. The one signal I would contest is C:H: this is a classic forgery where the cross-origin attacker forces state-changing actions but, under the same-origin policy, cannot read the SSE response stream back (cross-origin EventSource/fetch without CORS grants no read access). The true impact is integrity (firing state-changing event handlers and mounting a LiveView as the victim), so I assess confidentiality lower than the vendor. Net: a real, medium-to-high vulnerability worth patching, but it is a request-forgery requiring victim interaction and an authenticated victim session, not a wormable unauthenticated RCE. |
| Exploit ScenarioDerived | An attacker hosts a malicious web page and lures a logged-in djust user (with an active cookie session) to visit it. The page silently forces the victim's browser to GET the SSE stream URL - creating and mounting a LiveView as the victim - then issues a fetch POST with credentials:include and a JSON body sent as text/plain (a CORS simple request with no preflight) to the message endpoint, firing state-changing event handlers under the victim's identity. No public exploit code is identified, but the technique is straightforward and fully described in the advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 16, 2026
Cross-site request forgery in djust's Server-Sent-Events transport affects all versions prior to 1.0.7 and allows a cross-origin attacker page to drive a victim's cookie-authenticated SSE session, firing state-changing LiveView event handlers as that victim. Remote attackers need no authentication of their own, but exploitation requires the victim to be lured to an attacker-controlled page while holding an active authenticated djust session and while the SSE transport is enabled (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:N - integrity impact only, no confidentiality or availability impact). The flaw is fully fixed in 1.0.7 (Origin validated against ALLOWED_HOSTS with 403 for cross-origin requests, and POST endpoints now requiring Content-Type: application/json with 415 otherwise); no public exploit code was identified at time of analysis and the CVE has not been listed in CISA KEV.
RemediationAI
Upgrade djust to version 1.0.7 or later, which is the vendor-released patch: in that release all three SSE endpoints validate the request Origin against ALLOWED_HOSTS and return 403 for cross-origin requests, and the client→server POST endpoints require Content-Type: application/json and return 415 otherwise. If an immediate upgrade is not possible, apply one of the vendor-documented workarounds, understanding its trade-offs: either disable the SSE transport entirely (removing the attack surface but also removing SSE functionality for legitimate clients, and requiring you to confirm nothing in your application depends on it), or place the SSE endpoints behind a reverse proxy that enforces an Origin allowlist on the GET stream and POST message paths (restoring equivalent protection without a code change, but adding a component that must be kept in sync with ALLOWED_HOSTS and carefully configured so it does not break the SSE streaming responses or legitimate same-origin traffic). Because this is a CSRF-class issue, be aware that general Django CSRF middleware protections were bypassed by the @csrf_exempt decorators on these endpoints, so relying on standard CSRF settings alone does not mitigate it. Confirm patch status against the advisory at https://github.com/djust-org/djust/security/advisories/GHSA-pg97-jvmf-qfvc and the fixed release at https://github.com/djust-org/djust/releases/tag/v1.0.7. No vendor-released patch beyond these references is identified for older branches, so upgrading the package is the primary and most reliable action.
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
djust is a Python/Django library providing Phoenix LiveView-style reactive server-side rendering, with a Rust-powered rendering core. Alongside its WebSocket transport, it exposes a Server-Sent-Events transport: a GET stream endpoint that creates and mounts a LiveView for the connecting session, plus client→server POST endpoints that carry event messages into that LiveView. The vulnerability is a classic Cross-Site Request Forgery (CWE-352) rooted in missing origin and content-type enforcement rather than in cryptographic weakness. Prior to 1.0.7 the POST endpoints were decorated with @csrf_exempt, and the GET stream endpoint performed no Origin check at all. Because auth is carried by victim cookies, a malicious cross-origin page can (1) force the victim's browser to GET the stream URL, thereby creating and mounting a LiveView in the victim's authenticated context, and (2) POST to the message endpoint with credentials: include to invoke state-changing event handlers as the victim. The URL session_id is client-chosen and validated only for UUID format, so it provides no unforgeable CSRF token value, and a JSON payload sent with Content-Type: text/plain qualifies as a CORS simple request that triggers no preflight, allowing the cross-origin POST to be issued without an Origin preflight challenge. The upstream fix mirrors the WebSocket Cross-Site WebSocket Hijacking defense: all three SSE endpoints validate the request Origin against ALLOWED_HOSTS and reject cross-origin requests with 403, while the POST endpoints additionally require Content-Type: application/json and return 415 otherwise, closing the text/plain simple-request bypass.
Know when Djust 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:N/UI:R/S:U/C:H/I:H/A:N
Cross-origin CSRF: no attacker auth (PR:N) but victim must visit a malicious page (UI:R); same-origin policy blocks reading the SSE response (C:N), while state-changing handlers give I:H.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
djust provides Phoenix LiveView-style reactive server-side rendering for Django with Rust-powered performance. Prior to version 1.0.7, the SSE client→server POST endpoints are @csrf_exempt and the SSE GET stream endpoint had no Origin check, so a cross-origin page could drive a victim-cookie-authenticated SSE session: force the victim's browser to GET the stream URL (which creates and mounts a LiveView as the victim) and POST to the message endpoint with credentials: include to fire state-changing event handlers as the victim. The URL session_id is client-chosen (validated only for UUID *format*), so it is not a CSRF token, and a JSON body sent as text/plain is a CORS simple request with no preflight. The issue is fixed in 1.0.7. All three SSE endpoints validate the request Origin against ALLOWED_HOSTS (mirroring the WebSocket CSWSH defense) and reject cross-origin requests with 403; the POST endpoints additionally require Content-Type: application/json (415 otherwise), closing the text/plain simple-request bypass. As a workaround, disable the SSE transport, or front it with a proxy that enforces an Origin allowlist.
Technical POC Analysis
CWE-352 (Cross-Site Request Forgery) in djust's SSE transport endpoints.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Latest POC
1 PoC candidate from github (unverified)
Sign in to open the public PoC links collected for this CVE.
Executive ViewAI
djust versions prior to 1.0.7 contain a cross-site request forgery flaw in the Server-Sent Events transport, allowing an unauthenticated attacker to trigger state-changing LiveView events as an authenticated user who visits a malicious page. Exploitation requires user interaction and affects integrity only, with no public exploit identified at time of analysis. Organizations using djust-based applications should treat this as a high-priority integrity risk because unauthorized actions can corrupt application state and erode trust in platform controls.
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.
Authentication bypass in djust's WebSocket LiveView consumer allows unauthenticated remote clients to invoke protected e
Unauthenticated remote attackers can read live Django view and session state and invoke server-side handlers through dju
Mass assignment in djust, a Django library providing Phoenix LiveView-style reactive server-side rendering, allows any c
EUVD-2026-80856
GHSA-pg97-jvmf-qfvc
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB