CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-61592

CVE-2026-61592: Session Hijacking and Authorization Bypass in djust SSE Transport

Alon Barad
Alon Barad
Software Engineer

Sep 17, 2026·6 min read·12 visits

Executive Summary (TL;DR)

The djust framework prior to 1.0.7 accepted client-supplied session IDs in the Server-Sent Events (SSE) transport without verifying user ownership, enabling session hijacking and unauthorized state execution.

A high-severity session hijacking and authorization bypass vulnerability has been identified in the djust framework prior to version 1.0.7. The flaw resides in the Server-Sent Events (SSE) transport implementation, which keyed sessions solely by client-provided session identifiers without verifying session ownership or binding. This allows an attacker who possesses or guesses a victim's session identifier to send malicious post messages to execute arbitrary state machine event handlers under the identity and permissions of the victim.

Vulnerability Overview

The djust framework provides high-performance, reactive server-side rendering for Django applications, utilizing a Rust-optimized state machine to mirror UI and session states. The application supports two main underlying transports: WebSockets and Server-Sent Events (SSE). While the WebSocket implementation enforces strict, stateful authentication mapping, the SSE transport failed to implement equivalent authorization boundaries.\n\nBecause Server-Sent Events operate over stateless unidirectional streams paired with standard HTTP POST requests, the framework tracks session states on the server using an arbitrary key. Prior to version 1.0.7, this key was chosen and supplied directly by the client client-side without cryptographic verification. This structural gap exposes an unauthenticated attack surface to remote attackers, registered under the Common Weakness Enumeration as CWE-384 and CWE-862.\n\nIf an attacker can acquire, guess, or intercept an active client-chosen session identifier, they can issue arbitrary state manipulation calls. The server will process the event handlers inside the memory context of the victim's session. The execution context operates with the target victim's privileges, bypassing the identity check completely.

Root Cause Analysis

The root cause of this vulnerability lies in the stateless nature of SSE connections and how the framework manages its virtual DOM (VDOM) state machine index. When a user navigates to a reactive page, the server allocates a session state mapped to a unique session_id. However, in versions prior to 1.0.7, the framework relied entirely on a client-declared string value rather than an immutable, cryptographically generated token issued exclusively by the server.\n\nFurthermore, the message dispatcher endpoint /djust/api/message/ processed state mutations without validating the requesting principal's identity. The endpoint merely matched the incoming session_id payload to the corresponding backend state machine in memory. If a match was found, the endpoint executed the requested event handler within that state context.\n\nConsequently, there was no server-side validation to check whether the authenticated Django user (request.user) initiating the POST request matched the authenticated user who initially established the SSE channel. This lack of binding enables an attacker to perform cross-principal state hijacking by submitting POST commands with a stolen or predicted identifier.

Code Architecture & Analysis

An examination of the vulnerable code path reveals that the dispatcher accepted client-supplied arguments directly. Below is a conceptual illustration of the vulnerable dispatcher logic compared with the remediated framework implementation.\n\npython\n# Vulnerable SSE message dispatcher (Pre-1.0.7)\ndef handle_sse_message(request):\n payload = json.loads(request.body)\n session_id = payload.get(\"session_id\")\n \n # Retrieving state context purely by user-controlled key\n session_state = state_manager.get_session(session_id)\n if not session_state:\n return JsonResponse({\"error\": \"Session not found\"}, status=404)\n \n # CRITICAL: No validation of request.user against session creator\n event = payload.get(\"event\")\n handler = payload.get(\"handler\")\n result = session_state.dispatch_event(event, handler, payload.get(\"payload\"))\n return JsonResponse({\"status\": \"success\", \"result\": result})\n\n\nThe patch implemented in version 1.0.7 introduces explicit user principal binding. The framework now stores the owner's identity upon session initialization and enforces an explicit validation check on each incoming message.\n\npython\n# Remediation and principal binding (v1.0.7)\ndef handle_sse_message(request):\n payload = json.loads(request.body)\n session_id = payload.get(\"session_id\")\n \n session_state = state_manager.get_session(session_id)\n if not session_state:\n return JsonResponse({\"error\": \"Session not found\"}, status=404)\n \n # PATCH RESOLUTION: Validate principal identity of incoming request\n if session_state.owner_id != request.user.id:\n logger.warning(f\"Unauthorized session access: User {request.user.id} tried accessing {session_id}\")\n return JsonResponse({\"error\": \"Unauthorized session access\"}, status=403)\n \n event = payload.get(\"event\")\n handler = payload.get(\"handler\")\n result = session_state.dispatch_event(event, handler, payload.get(\"payload\"))\n return JsonResponse({\"status\": \"success\", \"result\": result})\n\n\nThis verification check successfully closes the vulnerability window. By validating owner_id against request.user.id, the server prevents any unauthenticated or unauthorized users from executing events on active reactive sessions.

Exploitation Methodology

Exploitation of this vulnerability requires that the target application has the Server-Sent Events (SSE) transport enabled and that the attacker has acquired a valid session_id. Attackers can potentially acquire the target ID via diagnostic log files, local cache directories, local storage access (via cross-site scripting), or predictive guessing if the identifier generation lacks sufficient entropy.\n\nOnce the attacker obtains the valid identifier, they can construct a direct HTTP POST request targeting the message execution endpoint. The attacker does not need to bypass the standard Django authentication cookies of the target user, since the dispatcher executes the logic based on the matched state memory of the active SSE session.\n\nhttp\nPOST /djust/api/message/ HTTP/1.1\nHost: vulnerable-application.com\nContent-Type: application/json\n\n{\n \"session_id\": \"victim_session_id_xyz\",\n \"event\": \"click\",\n \"handler\": \"execute_payment\",\n \"payload\": {\n \"recipient\": \"attacker_account\",\n \"amount\": 5000\n }\n}\n\n\nUpon receipt of the payload, the vulnerable backend state machine executes the execute_payment handler in the context of the user session associated with victim_session_id_xyz. The server then processes the transaction, allowing the attacker to conduct actions under the victim's identity.

Impact Assessment

The technical impact of CVE-2026-61592 is severe, compromising both confidentiality and integrity of active sessions within the application. An attacker can hijack the state machine of any user on the platform, allowing complete read access to state structures and write access to trigger form actions, administrative endpoints, or transactional logic.\n\nThe Common Vulnerability Scoring System (CVSS) base score is 7.4 (High). The attack vector is Network (AV:N), and user interaction is not required (UI:N). The attack complexity is assessed as High (AC:H) because the attacker must first discover an active, valid session identifier through separate channels before executing commands.\n\nAt the time of this analysis, there are no documented instances of active exploitation in the wild, nor has any weaponized exploit payload been observed. However, due to the direct route to authorization bypass, systems employing the SSE transport of djust remain highly exposed until patched.

Remediation & Mitigation Guidance

The definitive remediation is upgrading the djust package to version 1.0.7 or later, which implements secure session-to-principal bindings. The upgrade can be performed using standard Python package management tools.\n\nbash\npip install --upgrade djust>=1.0.7\n\n\nIf an immediate upgrade is not feasible, operators must apply a temporary workaround by disabling the SSE transport layer in the application configuration. This forces the application to fallback entirely to the secure WebSocket transport. Ensure that WebSockets are properly supported by your load balancers and proxy servers before applying this configuration change.\n\npython\n# Django settings.py mitigation example\nDJUST_SSE_ENABLED = False\n\n\nSecurity teams should also review application logs for requests directed to /djust/api/message/ containing identical session_id values but originating from distinct IP addresses or bearing different Django session cookies.

Fix Analysis (1)

Technical Appendix

CVSS Score
7.4/ 10
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N

Affected Systems

djust-org djust framework, versions prior to 1.0.7

Affected Versions Detail

Product
Affected Versions
Fixed Version
djust
djust-org
< 1.0.71.0.7
AttributeDetail
CWE IDCWE-384 / CWE-862
Attack VectorNetwork
CVSS Score7.4
EPSS Score0.00
ImpactSession Hijacking / Privilege Escalation
Exploit Statusnone
KEV Statusnot listed

MITRE ATT&CK Mapping

T1068Exploitation for Privilege Escalation
Privilege Escalation
CWE-862
Missing Authorization

The application lacks proper authorization checks on SSE event-handling requests, allowing attackers to access stateful sessions using user-controlled session identifiers.

References & Sources

  • [1]GitHub Security Advisory GHSA-f795-p5jw-j6g2
  • [2]djust Release v1.0.7
  • [3]NVD - CVE-2026-61592
  • [4]CVE Record - CVE-2026-61592
  • [5]Wiz Vulnerability Database

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•30 minutes ago•CVE-2026-126298
7.5

CVE-2026-126298: Quadratic Algorithmic Complexity Denial of Service in NLTK Tree.chomsky_normal_form

CVE-2026-126298 (also tracked as GHSA-r53h-rw34-8h97) is an algorithmic complexity Denial of Service (DoS) vulnerability in the Natural Language Toolkit (NLTK) Python library affecting all versions prior to 3.10.4. The vulnerability resides in the nltk.tree.transforms.chomsky_normal_form function and its corresponding public method Tree.chomsky_normal_form(). When transforming a parse tree into Chomsky Normal Form using the default right-factoring strategy, the function repeatedly invokes list.pop(0) inside a loop iterating over all children of a node. In CPython, removing the initial element of a standard list requires an O(N) memory shift operation, causing the overall binarization algorithm to degrade to O(N^2) quadratic time complexity relative to the width of a node. Furthermore, converting horizontal node width into vertical tree depth bypasses initial parsing depth bounds, triggering subsequent stack exhaustion (RecursionError) when recursive methods traverse the mutated structure. Unauthenticated remote attackers who can submit bracketed tree strings to applications invoking this transformation can exhaust single-threaded CPU resources or induce unhandled application exceptions.

Alon Barad
Alon Barad
1 views•12 min read
•about 2 hours ago•CVE-2026-126299
7.5

CVE-2026-126299: Quadratic Algorithmic Complexity Denial of Service in NLTK CCG Lexicon Parser

An algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) before version 3.10.4 allows remote unauthenticated attackers to cause a denial of service via crafted Combinatory Categorial Grammar (CCG) lexicon strings. The parser in nltk.ccg.lexicon.fromstring performs repeated immutable string slicing, concatenation, and regex tail capturing, resulting in O(n^2) CPU consumption when processing wide, flat category definitions.

Alon Barad
Alon Barad
3 views•10 min read
•about 3 hours ago•CVE-2026-126295
7.1

CVE-2026-126295: Path Traversal and Unconfined File Access in NLTK BllipParser

CVE-2026-126295 (also tracked as GHSA-fg9w-wfp5-j933) is a path confinement bypass vulnerability in the Natural Language Toolkit (NLTK) affecting versions 3.10.0 prior to 3.10.4. The flaw resides in nltk/parse/bllip.py within the BllipParser class and its factory method BllipParser.from_unified_model_dir(). Unlike sibling tool wrappers in NLTK that enforce data-root confinement via the nltk.pathsec module, BllipParser passes caller-supplied filesystem paths directly into the third-party bllipparser native C extension without validation. When an application passes untrusted input as model paths or directories to BllipParser, an attacker can force the native extension to open arbitrary files on the local filesystem. This leads to information disclosure through parser diagnostic oracles, local model tampering via shared directories, and denial of service by hanging worker threads on blocking special files (such as FIFOs or device nodes) or exhausting memory via oversized files.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 4 hours ago•CVE-2026-126300
5.3

CVE-2026-126300: Algorithmic Complexity Denial of Service in NLTK TreebankWordTokenizer.span_tokenize

CVE-2026-126300 (GHSA-ffr9-mgrr-wcvr) is an inefficient algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) Python library affecting versions 3.2.5 prior to 3.10.4. The flaw resides in the quote-restoration routine of TreebankWordTokenizer.span_tokenize and NLTKWordTokenizer.span_tokenize, where repeated calls to list.pop(0) over matched quote tokens introduce quadratic O(n^2) time complexity. An unauthenticated remote attacker who supplies input containing long sequences of double-quote characters can exhaust CPU resources and degrade service availability.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 5 hours ago•GHSA-GPWC-27CW-RH9R
5.3

CVE-2026-126301: Quadratic CPU Exhaustion in NLTK LegalitySyllableTokenizer

The Natural Language Toolkit (NLTK) versions 3.6 through 3.10.3 contain an algorithmic complexity vulnerability in the LegalitySyllableTokenizer.tokenize method. When processing tokens composed of continuous runs of vowels, an unguarded string reversal and set membership lookup loop executes in quadratic time relative to the input token length. Remote attackers capable of submitting arbitrary text to applications utilizing this tokenizer can trigger sustained single-core CPU exhaustion and application-level denial of service.

Amit Schendel
Amit Schendel
5 views•10 min read
•about 6 hours ago•CVE-2026-126304
8.7

CVE-2026-126304: Symlink Path Traversal in NLTK YCOECorpusReader

CVE-2026-126304 is a symlink path traversal vulnerability (CWE-59) in the Natural Language Toolkit (NLTK) versions 3.10.0 prior to 3.10.4. The YCOECorpusReader class constructs internal sub-readers for the 'psd' and 'pos' subdirectories using FileSystemPathPointer.join(), which relies exclusively on lexical string-prefix validation rather than canonical path resolution. An attacker who supplies a crafted YCOE corpus containing symbolic links in place of the 'psd' or 'pos' subdirectories can bypass directory confinement and read arbitrary files from sibling corpora or sensitive directories within the NLTK data sandbox.

Amit Schendel
Amit Schendel
6 views•9 min read