Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate as low-privileged user
-
DeliveryEnumerate object-scoped view IDs
-
ExploitRequest via HTTP GET / url_change / live_render
-
ExecutionBypass object-level authorization
-
ImpactRead/act on unauthorized object
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Object-level authorization, IDOR prevention
|
| Exploitation Conditions | Requires an authenticated djust application user (PR:L) and a view that defines a custom get_object (object-scoped view) - views without a custom get_object are explicitly unaffected (no-op). Exploitation works only against djust < 1.0.7 where the object-scoped view is exposed through any of three specific render entry points: the initial HTTP GET render, SPA url_change navigation, or a {% live_render %} embedded child (eager or lazy). Limiting factors: the attacker must already hold a valid account, must know or enumerate the target object identifier, and the target view must implement per-object authorization via get_object/has_object_permission (ADR-017); the WebSocket mount and event paths were already protected and are not vectors. No non-default configuration is otherwise needed. |
| Impact | This is a genuine but moderate-priority authorization flaw. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:N, base 7.1) indicates network-reachable, low-complexity exploitation requiring only a low-privileged authenticated account and no user interaction - a realistic profile for a multi-tenant web app where any registered user can attempt IDOR. Confidentiality impact is High (viewing objects the user is not authorized for) with Low integrity impact (the advisory notes the user can 'on some paths act on' the object) and no availability impact. There is NO CISA KEV listing, NO public POC, and NO EPSS score in the provided data, so there is no evidence of active or imminent exploitation - this is a defensive/patch-hygiene priority, not an emergency. The primary risk driver is the low exploitation barrier (any authenticated user, default configuration, no special feature toggle), tempered by the low real-world footprint of the affected framework. The input tag 'Authentication Bypass' is a mislabel: CWE-639 and the advisory both describe broken object-level authorization (IDOR), not authentication bypass - the attacker must already be authenticated. |
| Exploit ScenarioDerived | An authenticated low-privileged user of a djust-based application identifies an object-scoped view (e.g., /orders/1234) and directly loads a URL for an object ID belonging to another tenant/user via HTTP GET, SPA url_change navigation, or by composing it as a {% live_render %} embedded child - all three paths bypassed the get_object/has_object_permission checks that were enforced only on WebSocket mount/event. The unauthorized object renders, disclosing its data and on some paths permitting actions on it. No public POC is identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 16, 2026
Broken object-level access control in djust before 1.0.7 lets an authenticated user view - and on some paths act on - object-scoped views they are not authorized for, by loading the page via a direct HTTP GET, navigating to it through SPA url_change, or embedding it as a {% live_render %} child (eager or lazy). The flaw exists because per-object authorization (get_object plus has_object_permission, ADR-017) was enforced only on the WebSocket mount and event paths, leaving these three render entry points unchecked; views that do not define a custom get_object are unaffected. Exploitation requires a valid account (CVSS PR:L), knowledge or enumeration of the target object identifier, and a djust deployment older than 1.0.7 that exposes an object-scoped view through any of those paths, giving high confidentiality impact with limited integrity impact (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:N, score 7.1); no public exploit code was identified at time of analysis and CISA KEV does not list this issue.
RemediationAI
Upgrade to djust 1.0.7 or later - the vendor-released patch (fixed version 1.0.7) routes HTTP GET, SPA url_change, and {% live_render %} (eager and lazy) through the shared enforce_object_permission chokepoint, returning 403 on HTTP GET, emitting a permission_denied frame and skipping the render on url_change, and refusing the embedded child embed; see https://github.com/djust-org/djust/security/advisories/GHSA-c7c5-5j6r-q957 and the release at https://github.com/djust-org/djust/releases/tag/v1.0.7. The advisory states there is no reliable workaround short of upgrading, so if immediate patching is not possible, the compensating control is to stop exposing object-scoped views (those with a custom get_object) through the HTTP-GET, url_change, and live_render paths until 1.0.7 is deployed - for example by disabling SPA url_change navigation for those views and removing or gating their {% live_render %} embeds - accepting the trade-off that this breaks direct-link access and embedded composition for those views while the WebSocket mount and event paths remain the only usable, and protected, access route. Note that views without a custom get_object require no change.
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 server-driven UI framework (distributed via pip as pkg:pip/djust) that renders live views over both HTTP and WebSocket channels. ADR-017 defines its per-object authorization model: a view implements get_object to resolve the target instance and has_object_permission to decide whether the current user may access it. Prior to 1.0.7 that check was wired into the WebSocket mount and event dispatch paths but omitted from the parallel render paths - the initial HTTP GET render, SPA url_change navigation, and the {% live_render %} embedded child component (both eager and lazy variants). This maps to CWE-639 (Authorization Bypass Through User-Controlled Key), the classic IDOR pattern, because the object identifier supplied by the client is used to fetch and render the object without re-running the object-level permission check on those three entry points. The 1.0.7 fix consolidates all render entry points behind a single enforce_object_permission chokepoint, so HTTP GET returns 403, url_change emits a permission_denied frame and skips rendering, and {% live_render %} refuses the embed; the check is a no-op for views without a custom get_object, which is why those views were never vulnerable.
Know when Django 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:N/S:U/C:H/I:L/A:N
Network-reachable, low-complexity IDOR requiring any authenticated account (PR:L); high confidentiality from viewing unauthorized objects, low integrity since some paths permit acting on them, no availability impact.
Primary rating from Vendor (https://github.com/djust-org/djust).
CVSS VectorVendor: https://github.com/djust-org/djust
Lifecycle Timeline
2DescriptionCVE.org
Impact
djust's per-object authorization (get_object + has_object_permission, ADR-017) was enforced on the WebSocket mount and event paths but not on three other render entry points: (a) the initial HTTP GET render, (b) SPA url_change navigation, and (c) {% live_render %} embedded child views. An authenticated user could therefore view (and on some paths act on) an object they are not authorized for by loading the page directly, navigating to it via SPA url-change, or composing it as an embedded child - a classic IDOR / broken object-level access control on object-scoped views.
Patches
Fixed in djust 1.0.7. All render entry points now route through a shared enforce_object_permission chokepoint: HTTP GET returns 403, url_change emits a permission_denied frame and skips the render, and {% live_render %} (eager + lazy) refuses the embed. Views without a custom get_object are unaffected (no-op).
Workarounds
No reliable workaround short of upgrading. Do not expose object-scoped views through the HTTP-GET / url_change / live_render paths until patched.
Technical POC Analysis
Bug class: CWE-639, Authorization Bypass Through User-Controlled Key (the advisory also tags CWE-862, Missing Authorization).
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 deployments older than 1.0.7 can allow any authenticated user to reach object-scoped views they are not authorized to access, affecting confidentiality and, in some paths, limited integrity of protected data. Leadership should prioritize remediation because exploitation requires only a valid account and knowledge or enumeration of the target object identifier, and it may expose sensitive customer or operational records. No public exploit identified at time of analysis and CISA KEV does not list this issue, but the lack of a vendor-released patch increases the need for interim access-control hardening.
No vendor-released patch identified at time of analysis. Interim mitigations: add custom get_object and has_object_permission to affected object-scoped views; disable {% live_render %} child rendering and SPA url_change navigation to protected views; enforce authorization at every render entry point; restrict and monitor authenticated accounts that can enumerate object identifiers; and log/alert on unauthorized object access attempts.
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
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
The package python/cpython from 0 and before 3.6.13, from 3.7.0 and before 3.7.10, from 3.8.0 and before 3.8.8, from 3.9
In Django 1.10.x before 1.10.8 and 1.11.x before 1.11.5, HTML autoescaping was disabled in a portion of the template for
An issue was discovered in Django 3.2 before 3.2.14 and 4.0 before 4.0.6. Rated critical severity (CVSS 9.8), this vulne
Django 3.1.x before 3.1.13 and 3.2.x before 3.2.5 allows QuerySet.order_by SQL injection if order_by is untrusted input
Django before 1.11.27, 2.x before 2.2.9, and 3.x before 3.0.1 allows account takeover. Rated critical severity (CVSS 9.8
An authentication/authorization bypass in the djust Python live-view framework (versions prior to 1.0.7) lets unauthenti
Unauthenticated arbitrary Python module import in djust before 1.0.7 lets any client that can reach the WebSocket or SSE
Django 1.11 before 1.11.29, 2.2 before 2.2.11, and 3.0 before 3.0.4 allows SQL Injection if untrusted data is used as a
Cross-site scripting (XSS) vulnerability in the dismissChangeRelatedObjectPopup function in contrib/admin/static/admin/j
Forged content modification in django-page-cms through 2.0.13 lets unauthenticated remote attackers exploit five CSRF-ex
Cross-site request forgery in djust's Server-Sent-Events transport affects all versions prior to 1.0.7 and allows a cros
Unauthenticated remote attackers can read live Django view and session state and invoke server-side handlers through dju
EUVD-2026-81305
GHSA-c7c5-5j6r-q957
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB