Blog / Security Advisories

Django Security Releases November 2026: GeoJSON SSRF, Cache Vary Leak, Admin Hash Exposure, and How to Upgrade

On November 3, 2026, the Django team released 6.1.3, 6.0.10, and 5.2.19 with fixes for six vulnerabilities. Two let attackers make your server send network requests through GeoDjango, one can serve a private cached page to the wrong user, and one shows password hashes to admin users who should only be able to view. Here is what each one means, who is affected, and how to upgrade.

· 9 min read

The Django November 2026 security release fixes six CVEs across every supported line: 6.1.3, 6.0.10, and 5.2.19. The Django team rates one issue Moderate, the GeoJSON server-side request forgery CVE-2026-111362, and the other five Low. “Low” in Django’s scale often means “needs a specific feature or configuration,” and three of these touch features that many production apps use: GeoDjango, the cache middleware, and the admin.

This article was created with AI assistance. Facts were checked against the official Django security release announcement of November 3, 2026 and Django’s security issue archive on November 7, 2026. Confirm details in the official advisory before acting.

TL;DR: what to install

If you runUpgrade toNotes
Django 6.16.1.3All six CVEs
Django 6.06.0.10All six CVEs
Django 5.2 LTS5.2.19Five CVEs; CVE-2026-113733 does not affect 5.2
Django 5.1, 4.2, or olderMove to 5.2.19 or 6.xEnd of life: no fixes
pip install --upgrade "Django~=6.1.3"    # or "Django~=6.0.10" / "Django~=5.2.19"
python -m django --version

If you skipped the October 6, 2026 release (6.1.2, 6.0.9, 5.2.18), this upgrade also brings its fixes, including the HTTP header parsing denial of service CVE-2026-84429 and the model formset privilege issue CVE-2026-87975.

The six vulnerabilities

CVEIssueSeverityWho is affected
CVE-2026-111362SSRF via the crs member of GeoJSON geometriesModerateGeoDjango apps that parse untrusted GeoJSON
CVE-2026-114582SSRF and file reads via SpatialReference string inputLowGeoDjango apps that pass user strings to SpatialReference
CVE-2026-113593Private data exposure via empty and missing Vary headers in the cacheLowSites using UpdateCacheMiddleware or cache_page()
CVE-2026-113733Password hashes shown to “view only” admin users with some custom user modelsLow6.1 and 6.0 admin with custom user models
CVE-2026-108147Memory exhaustion in MultiPartParser with base64-encoded uploadsLowAny app accepting multipart uploads
CVE-2026-111211Log injection via unescaped geometry form valuesLowGeoDjango forms using GeometryField

GeoDjango SSRF: CVE-2026-111362 and CVE-2026-114582

GeoDjango hands geometry and spatial reference data to the GDAL library. GDAL is helpful in a way that is dangerous for web input: it resolves URLs and reads files when it is given a reference to one.

  • CVE-2026-111362 (Moderate). The legacy GeoJSON format let a geometry carry a crs member that names its coordinate reference system by URL. OGRGeometry passed that on to GDAL, which fetched it. Any endpoint that accepts GeoJSON, such as a map editor, a delivery zone API, or a Django REST Framework GIS serializer, could be made to send requests from your server to an address the attacker chooses.
  • CVE-2026-114582. SpatialReference passed string input straight to GDAL, which by default resolves URLs and reads local files. Code that builds a spatial reference from a user-supplied string could be used for outbound requests or file reads.

Classic SSRF impact applies: reaching cloud metadata services at 169.254.169.254, internal admin panels, or databases that trust the app server’s network position. After upgrading, also:

  • Restrict egress from app servers to the hosts they need, and block the cloud metadata address or require IMDSv2 on AWS.
  • Validate GeoJSON before parsing. Reject or strip crs members; current GeoJSON (RFC 7946) always uses WGS 84 and does not need them.
  • Allowlist spatial references as integer SRIDs instead of accepting free-form strings.

Cache key collision: CVE-2026-113593

Django’s per-view and site-wide caches store a response once and build the cache key from the headers listed in its Vary header, such as Cookie or Authorization. The bug: a request that omitted a header listed in Vary and a request that sent the header with an empty value got the same cache key.

The result depends on what you cache, but the risk is a private, per-user response being served to someone else. Django rates it Low because exploitation needs a particular combination of caching and header handling. If you use cache_page() or UpdateCacheMiddleware on any view that changes by user, upgrade and then clear the cache:

python manage.py shell -c "from django.core.cache import cache; cache.clear()"

Better still, keep authenticated responses out of shared caches altogether. Mark them with @never_cache or Cache-Control: private, and check that your CDN respects it. This is the same lesson as this week’s Next.js cache disclosure fixes: caches are one of the most common ways one user ends up seeing another user’s data.

Password hashes for view-only admins: CVE-2026-113733

On Django 6.1 and 6.0, staff users with only the “view” permission on a custom user model could see the full password hash, when that model is not the one set in AUTH_USER_MODEL or inherits from it through multi-table inheritance. Hashes are not passwords, but weak passwords hashed with a fast algorithm can be cracked offline, and leaked hashes are a reportable incident in many compliance regimes.

Review which staff accounts have view access to user models, and confirm your PASSWORD_HASHERS setting starts with a slow hasher such as Argon2 or PBKDF2 with Django’s default iteration count. The same mistake is common in APIs: a serializer that returns every field of a user model. Our guide to mass assignment covers the write side of that problem.

Uploads and logs: CVE-2026-108147 and CVE-2026-111211

  • CVE-2026-108147. Multipart file parts sent with Content-Transfer-Encoding: base64 were buffered entirely in memory before reaching upload handlers, ignoring the file size limits that normally stream large uploads to disk. An unauthenticated attacker could exhaust worker memory on any endpoint that parses multipart bodies. Until you upgrade, a request body limit at your reverse proxy, such as client_max_body_size in nginx, caps the damage.
  • CVE-2026-111211. GeometryField logged invalid submitted values without escaping, so control characters such as newlines could forge log lines. If you feed logs into a SIEM, forged lines can hide activity or trigger false alerts.

Check whether you are affected

# Version
python -m django --version

# GeoDjango in use?
grep -rn "django.contrib.gis" */settings*.py settings/ 2>/dev/null
grep -rnE "OGRGeometry|GEOSGeometry|SpatialReference|GeometryField" --include='*.py' . | grep -v migrations

# Cache middleware or per-view caching?
grep -rnE "UpdateCacheMiddleware|FetchFromCacheMiddleware|cache_page" --include='*.py' .

Remember that Django often reaches production through more than one path: the app image, background workers, scheduled jobs, and internal tools. Pin the patched version in every requirements or lock file, rebuild every image, and confirm with python -m django --version in each running container.

How DAST tools help you catch issues like this sooner

Upgrading Django is the fix for these CVEs. But each of them is a framework-level version of a bug that applications write themselves all the time: an endpoint that fetches a URL from user input, a cache that mixes users, an API that returns a field it should not, an upload handler with no limit. Dynamic application security testing finds those in your running app, whatever caused them.

DastPilot scans your APIs from an OpenAPI spec or Postman collection, as every role you configure. The checks most relevant to this release:

  • SSRF probes on parameters that accept URLs and references, including JSON body fields, which is where GeoJSON-style SSRF lives.
  • Sensitive data exposure: flags password hashes, tokens, secrets, and PII returned in responses beyond what your spec declares, the API version of CVE-2026-113733.
  • Cross-user access (BOLA) and role checks (BFLA): requests each user’s resources as another user and replays privileged operations as lower roles, catching per-user data served to the wrong person.
  • Injection and input handling: SQL, NoSQL, command, and template injection, plus malformed input that triggers server errors.
  • Regression tracking: compares each scan with the last, so an issue that returns after a framework upgrade is flagged as reopened.

Pair DAST with pip-audit or your dependency scanner, which tells you which Django version you run, and run both in your CI/CD pipeline. For Python runtime fixes from the past month, see our Python October 2026 security release guide.

Frequently asked questions

Which Django versions fix the November 2026 vulnerabilities?

Django 6.1.3, 6.0.10, and 5.2.19, released on November 3, 2026, fix all of the issues that affect their lines. Django 5.1, 4.2, and older are end of life and do not receive fixes.

What is CVE-2026-111362?

CVE-2026-111362 is a Moderate-severity server-side request forgery in GeoDjango. OGRGeometry did not restrict the legacy crs member of GeoJSON input, which can name a coordinate reference system by URL, so GDAL could be made to send network requests to attacker-chosen destinations. It is fixed in 6.1.3, 6.0.10, and 5.2.19.

Does CVE-2026-113593 affect my Django site?

It affects sites that use Django’s cache middleware (UpdateCacheMiddleware) or the cache_page() decorator. A request that omitted a header listed in Vary and one that sent it empty got the same cache key, which can expose private cached responses. Upgrade, then clear the cache.

Which Django apps are affected by CVE-2026-113733?

Django 6.1 and 6.0 admin sites with a custom user model that is not AUTH_USER_MODEL or inherits from it through multi-table inheritance. Staff with only view permission on that model could see full password hashes. Django 5.2 is not affected.

How do I mitigate the Django multipart memory exhaustion bug?

Upgrade to a fixed version. Until then, set a request body size limit at your reverse proxy, for example client_max_body_size in nginx, because CVE-2026-108147 buffers base64-encoded file parts in memory regardless of Django’s upload settings.

Can a DAST scanner find SSRF and data exposure in Django APIs?

Yes. DAST tools such as DastPilot send SSRF probes to URL and reference parameters, flag password hashes and other sensitive fields in responses, and test cross-user access as multiple roles. They test your running app, so they catch both framework-level and application-level versions of these bugs.

Find SSRF and data leaks before attackers do

DastPilot probes every documented parameter for SSRF and injection, flags sensitive fields in responses, and tests BOLA and BFLA as each role. 30-day free trial, no credit card required.