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-69131

CVE-2026-69131: Missing Authorization in django-filer Bulk Deletion Admin Action

Alon Barad
Alon Barad
Software Engineer

Nov 18, 2026·9 min read·0 visits

Executive Summary (TL;DR)

Authenticated staff users in django-filer (< 3.5.0) with model-level delete permissions can bypass per-folder read-only restrictions (FolderPermission) via the bulk delete admin action when FILER_ENABLE_PERMISSIONS is enabled.

A missing authorization vulnerability exists in django-filer versions prior to 3.5.0 when the optional per-folder permission system (FILER_ENABLE_PERMISSIONS) is enabled. The bulk delete admin action (delete_files_or_folders) verifies global Django model-level deletion permissions but fails to enforce object-level FolderPermission edit checks. Consequently, an authenticated staff user holding model-level delete rights can delete files, folders, and directory trees from folders where their access has been explicitly restricted to read-only via FolderPermission.

Vulnerability Overview

django-filer is a file and image management application designed for the Django web framework and commonly deployed alongside django-cms. It provides a virtual directory structure (Folder models) and manages media assets (File and Image models) through a custom extension of the Django administrative interface. By default, django-filer relies entirely on standard Django model-level permissions (add, change, delete, view) to govern administrative actions across all files and directories.

For multi-tenant or segmented editorial workflows, django-filer provides an optional object-level permission system activated by setting FILER_ENABLE_PERMISSIONS = True in the Django project configuration. When enabled, administrators can define fine-grained access control lists using FolderPermission records. These records apply to specific folders, users, or groups, enforcing three specific capability flags: can_read, can_edit, and can_add_children.

In versions of django-filer prior to 3.5.0, the bulk deletion administrative action (delete_files_or_folders) located in filer/admin/folderadmin.py fails to validate object-level permissions before executing deletions. While the method checks whether the requesting user possesses global Django model-level deletion permission via self.has_delete_permission(request), it omits calls to check_folder_edit_permissions and check_files_edit_permissions.

This omission is classified under CWE-862 (Missing Authorization) and CWE-639 (Authorization Bypass Through User-Controlled Key). An authenticated staff user who holds global model-level delete permissions (filer.delete_file, filer.delete_folder, or filer.delete_image) but is explicitly restricted to read-only access on a specific folder (can_edit = DENY, can_read = ALLOW) can submit a crafted request to the bulk deletion endpoint and delete files, subdirectories, and descendant items within that restricted folder.

Root Cause Analysis

The root cause of CVE-2026-69131 lies in an architectural inconsistency between how django-filer models object-level permissions and how individual administrative actions enforce them. The FolderPermission model defines only three boolean/tristate permission fields: can_read, can_edit, and can_add_children. It does not define a separate can_delete attribute. Instead, the permission architecture treats any state-modifying operation on an existing folder or file—including moving, renaming, copying, resizing, or deleting—as an edit operation governed by the can_edit privilege.

To enforce this design across the custom admin views in filer/admin/folderadmin.py, the codebase relies on two helper functions: check_folder_edit_permissions(request, folders_queryset) and check_files_edit_permissions(request, files_queryset). When FILER_ENABLE_PERMISSIONS is active, these functions iterate over every selected object (and recursively traverse descendant folders and files) to verify that the requesting user has has_edit_permission(request) on each item. If any item in the hierarchy evaluates to can_edit = DENY, the helper function immediately raises django.core.exceptions.PermissionDenied.

Every other mutating admin action in FolderAdmin—such as move_files_and_folders, copy_files_and_folders, resize_images, and rename_files—explicitly invokes both check_files_edit_permissions and check_folder_edit_permissions at the beginning of the action handler. However, the delete_files_or_folders handler relied solely on self.has_delete_permission(request).

Because delete_files_or_folders operates on a bulk selection of items passed via POST parameters (_selected_action), self.has_delete_permission(request) is invoked without an obj argument (obj=None). In Django's ModelAdmin architecture, calling has_delete_permission(request, obj=None) only queries the authentication backend for global model-level permissions (e.g., user.has_perm('filer.delete_folder')). Because no object instance is evaluated during this check, and the subsequent queryset-level edit permission checks were omitted, the object-level FolderPermission boundary was bypassed entirely.

Code Analysis

The vulnerability resides in the FolderAdmin.delete_files_or_folders method inside filer/admin/folderadmin.py. In versions <= 3.4.4, the method begins by checking global deletion permissions and immediately proceeds to resolve the current directory and build the deletion confirmation or execution context.

# Vulnerable implementation in filer/admin/folderadmin.py (<= 3.4.4)
def delete_files_or_folders(self, request, files_queryset, folders_queryset):
    if not self.has_delete_permission(request):
        raise PermissionDenied
 
    current_folder = self._get_current_action_folder(
        request, files_queryset, folders_queryset)
    # Proceeds to enumerate deletable objects and execute deletion on POST

In pull request #1605 (merged via commit 742ba4c3094dd75e586ca3a05e6ad2703de4553b), the maintainers patched the flaw by inserting explicit calls to check_files_edit_permissions and check_folder_edit_permissions immediately after the model-level has_delete_permission check.

--- a/filer/admin/folderadmin.py
+++ b/filer/admin/folderadmin.py
@@ -756,6 +756,13 @@ def delete_files_or_folders(self, request, files_queryset, folders_queryset):
         if not self.has_delete_permission(request):
             raise PermissionDenied
 
+        # Check that the user has per-folder edit permission on every selected
+        # file and folder (and their descendants). Without this, a user with
+        # only read access to a folder could delete its contents when the
+        # optional per-folder permission system is enabled.
+        check_files_edit_permissions(request, files_queryset)
+        check_folder_edit_permissions(request, folders_queryset)
+
         current_folder = self._get_current_action_folder(
             request, files_queryset, folders_queryset)

To understand why this two-line addition provides recursive protection, it is necessary to examine how check_folder_edit_permissions and check_files_edit_permissions operate within filer/admin/folderadmin.py:

# Helper functions in filer/admin/folderadmin.py
def check_files_edit_permissions(request, files):
    for f in files:
        if not f.has_edit_permission(request):
            raise PermissionDenied
 
def check_folder_edit_permissions(request, folders):
    for f in folders:
        if not f.has_edit_permission(request):
            raise PermissionDenied
        check_files_edit_permissions(request, f.files)
        check_folder_edit_permissions(request, f.children.all())

The fix is complete for the bulk delete code path. check_folder_edit_permissions validates not only the top-level folders selected in folders_queryset, but also recursively checks every child file (f.files) and child subfolder (f.children.all()) down the directory tree. If an attacker attempts to delete an editable parent folder that contains a restricted read-only subfolder (can_edit = DENY), the recursive traversal detects the restricted descendant and aborts the entire operation with PermissionDenied before any database deletion occurs.

Exploitation

Exploiting CVE-2026-69131 requires three specific preconditions. First, the target Django application must have FILER_ENABLE_PERMISSIONS = True configured in settings.py. Second, the attacker must possess valid credentials for an active staff user account (is_staff=True) that has been granted global model-level delete permissions (filer.delete_folder, filer.delete_file, or filer.delete_image), which is a common baseline configuration when administrators rely on FolderPermission records to restrict specific directory trees. Third, the target folder or file must be covered by a FolderPermission rule that denies edit access (can_edit = DENY) while permitting read access (can_read = ALLOW).

Once authenticated to the Django admin interface, the attacker can navigate to the root directory listing or parent folder view (/admin/filer/folder/). In the directory listing table, each folder and file is rendered with an action checkbox formatted as folder-<PK> or file-<PK>. Although the user is denied move, rename, or edit actions on the restricted folder, they can select the checkbox corresponding to the restricted item and invoke the delete_files_or_folders action.

To bypass the intermediate confirmation page and execute the deletion in a single request, the attacker submits an HTTP POST request directly to the directory listing endpoint with the parameter post=yes:

POST /admin/filer/folder/ HTTP/1.1
Host: target-django-cms.local
Content-Type: application/x-www-form-urlencoded
Cookie: sessionid=<VALID_STAFF_SESSION>; csrftoken=<CSRF_TOKEN>
 
csrfmiddlewaretoken=<CSRF_TOKEN>&action=delete_files_or_folders&post=yes&_selected_action=folder-123

The upstream patch in commit 742ba4c3094dd75e586ca3a05e6ad2703de4553b includes a regression test (test_delete_action_requires_edit_permission in tests/test_permissions.py) that demonstrates the exact reproduction sequence:

# Excerpt from tests/test_permissions.py in commit 742ba4c3094dd75e586ca3a05e6ad2703de4553b
delete_perms = Permission.objects.filter(
    codename__in=("delete_folder", "delete_file", "delete_image")
)
self.test_user1.user_permissions.add(*delete_perms)
 
FolderPermission.objects.create(
    type=FolderPermission.ALL, everybody=True,
    can_edit=FolderPermission.DENY,
    can_read=FolderPermission.ALLOW,
    can_add_children=FolderPermission.DENY,
)
 
target = Folder.objects.create(name="readonly_target", owner=self.superuser)
 
self.client.login(username=self.test_user1.username, password="secret")
url = reverse('admin:filer-directory_listing-root')
response = self.client.post(url, {
    'action': 'delete_files_or_folders',
    'post': 'yes',
    helpers.ACTION_CHECKBOX_NAME: ['folder-%d' % target.id],
})

On vulnerable versions (<= 3.4.4), the server processes the deletion, removes the Folder record and all associated child Image or File instances from the database and underlying storage backend, and responds with an HTTP 302 Found redirect back to the directory listing. On patched versions (>= 3.5.0), the server intercepts the unauthorized action inside check_folder_edit_permissions and returns an HTTP 403 Forbidden response.

Impact Assessment

CVE-2026-69131 is scored at 4.3 (Medium) under CVSS v3.1 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N). The Attack Vector is Network (AV:N) as the Django administrative interface is accessible over HTTP/HTTPS, and Attack Complexity is Low (AC:L) because triggering the flaw requires only a standard HTTP POST request with no race conditions or complex state preparation. Privileges Required is Low (PR:L), reflecting the requirement for an authenticated staff user account with model-level delete privileges, and User Interaction is None (UI:N).

The impact is strictly confined to Integrity (I:L), with no Confidentiality (C:N) or Availability (A:N) impact recorded in the CVSS vector. As noted in the GitHub Security Advisory (GHSA-vf85-8ff2-3r9w), django-filer files are designed to be world-downloadable by default, and the flaw does not expose restricted file contents or system memory. Under CVSS v3.1 scoring conventions for data-level vulnerabilities, the unauthorized deletion of application-level records (files and folder structures) without disrupting the underlying host or web server availability is categorized as a low-to-moderate integrity violation rather than a system availability failure.

In practical terms, the vulnerability undermines multi-department or multi-tenant editorial isolation within django-cms and Django deployments. Organizations that use FILER_ENABLE_PERMISSIONS = True typically grant all staff editors baseline model permissions (add, change, delete on File, Image, and Folder) so they can manage assets inside their own assigned folders, while applying FolderPermission rules with can_edit = DENY to protect shared corporate assets or folders owned by other departments. An attacker with such a restricted staff account can destroy media assets, templates, or document repositories belonging to other teams.

Deployments that leave FILER_ENABLE_PERMISSIONS at its default setting (False) are completely unaffected by this vulnerability, as those environments do not enforce object-level FolderPermission boundaries and rely intentionally on global Django model permissions.

Remediation

The primary remediation is to upgrade django-filer to version 3.5.0 or later, which incorporates commit 742ba4c3094dd75e586ca3a05e6ad2703de4553b. Administrators can update the package via pip and restart the Django application server:

pip install --upgrade "django-filer>=3.5.0"

> [!NOTE] > Verify whether your project sets FILER_ENABLE_PERMISSIONS = True in settings.py. If FILER_ENABLE_PERMISSIONS is omitted or explicitly set to False, the deployment does not use per-folder access controls and is not vulnerable to CVE-2026-69131.

For environments running FILER_ENABLE_PERMISSIONS = True where an immediate package upgrade to 3.5.0 is not feasible, administrators can apply two immediate workarounds:

  1. Revoke Global Model-Level Delete Permissions: Audit all staff users and Django Group definitions in auth_user_user_permissions and auth_group_permissions. Remove the filer.delete_file, filer.delete_folder, and filer.delete_image permissions from any non-administrative staff accounts that are subject to read-only FolderPermission restrictions. Without the global delete_* permissions, self.has_delete_permission(request) returns False and blocks the bulk delete action at the model level.
  2. Override FolderAdmin.delete_files_or_folders in Custom Code: If staff users must retain the ability to delete items in their own editable folders prior to upgrading, register a custom subclass of FolderAdmin in the project that wraps delete_files_or_folders with explicit calls to check_files_edit_permissions(request, files_queryset) and check_folder_edit_permissions(request, folders_queryset).

Security operations teams should also review web server access logs and Django django_admin_log entries for suspicious POST requests to /admin/filer/folder/ containing action=delete_files_or_folders originating from restricted staff accounts.

Official Patches

django-cmsdjango-filer 3.5.0 Official Release
django-cmsGitHub Security Advisory GHSA-vf85-8ff2-3r9w

Fix Analysis (2)

Technical Appendix

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

Affected Systems

django-filer (PyPI package: django-filer) versions < 3.5.0 with FILER_ENABLE_PERMISSIONS=True

Affected Versions Detail

Product
Affected Versions
Fixed Version
django-filer
django-cms
< 3.5.0 (<= 3.4.4)3.5.0
AttributeDetail
CVE / GHSA IDCVE-2026-69131 / GHSA-vf85-8ff2-3r9w
Weakness ClassCWE-862 (Missing Authorization) / CWE-639
CVSS v3.1 Score4.3 Medium (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N)
Attack VectorNetwork (Authenticated Staff User via Django Admin POST)
PreconditionsFILER_ENABLE_PERMISSIONS=True & Model-level delete_* permissions
Security ImpactUnauthorized deletion of files and folders in read-only directories
Exploit StatusPoC (Upstream regression test in PR #1605)
Patched Versiondjango-filer 3.5.0

MITRE ATT&CK Mapping

T1068Exploitation for Privilege Escalation
Privilege Escalation
CWE-862
Missing Authorization

The software does not perform authorization checks when an actor attempts to access a resource or perform an action, allowing users to bypass object-level permission boundaries (also tracked under CWE-639: Authorization Bypass Through User-Controlled Key).

Known Exploits & Detection

GitHubOfficial pull request containing the unit test proof-of-concept (test_delete_action_requires_edit_permission) demonstrating the authorization bypass.

Vulnerability Timeline

Vulnerability identified and initial patch committed (29d20ec0de13d7f77fa2cea93166f8d50a3f508d)
2026-07-03
Pull Request #1605 merged (742ba4c3094dd75e586ca3a05e6ad2703de4553b) and django-filer 3.5.0 released
2026-07-06
GitHub Security Advisory GHSA-vf85-8ff2-3r9w and CVE-2026-69131 published
2026-11-18

References & Sources

  • [1]GitHub Security Advisory: GHSA-vf85-8ff2-3r9w
  • [2]GitHub Pull Request #1605: Enforce edit permissions on bulk delete
  • [3]Fix Commit 742ba4c3094dd75e586ca3a05e6ad2703de4553b (PR Merge)
  • [4]Fix Commit 29d20ec0de13d7f77fa2cea93166f8d50a3f508d (Initial Patch)
  • [5]django-filer Release 3.5.0
  • [6]CVE-2026-69131 Official Record on CVE.org

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

•about 1 hour ago•CVE-2026-75506
6.6

CVE-2026-75506: Second-Order OS Command Injection in OliveTin shellAfterCompleted Hook

CVE-2026-75506 (GHSA-vc6p-m6vx-6cwq) is a second-order OS command injection vulnerability in OliveTin affecting versions 3000.0.0 prior to 3000.18.1. The post-execution hook mechanism, shellAfterCompleted, interpolates runtime execution outputs and username variables directly into a shell command string passed to sh -c without validation. When an action emits untrusted output containing shell metacharacters, those metacharacters break out of the intended syntax and execute arbitrary OS commands under the context of the OliveTin service process.

Alon Barad
Alon Barad
3 views•10 min read
•about 2 hours ago•CVE-2026-71481
7.5

CVE-2026-71481: Cryptographic Signature Verification Bypass in ALTCHA PHP Library

CVE-2026-71481 (GHSA-82w8-65qw-gch6) is a cryptographic signature verification bypass (CWE-347) in the altcha-org/altcha PHP library affecting versions 2.0.0 through 2.0.2. Due to a flawed conditional check in the verifySolution method, omitting the signature field from a submitted challenge payload causes the server to skip HMAC verification entirely, even when a server-side HMAC secret is configured. Unauthenticated remote attackers can exploit this flaw to self-issue low-difficulty Proof-of-Work challenges, solve them with trivial effort, and bypass CAPTCHA controls.

Alon Barad
Alon Barad
4 views•10 min read
•about 5 hours ago•CVE-2026-61618
6.9

CVE-2026-61618: Improper Input Validation of KZG Accumulator Limbs in snark-verifier

CVE-2026-61618 (GHSA-265x-v3qf-ff6p) is an improper input validation vulnerability (CWE-20) in Axiom Crypto's snark-verifier library prior to version 0.2.5. The library decodes KZG accumulator public-instance limbs without enforcing canonical bit-width bounds prior to elliptic curve coordinate reconstruction. In the Ethereum Virtual Machine (EVM) loader path, the generated Yul bytecode validates that reconstructed affine coordinates lie on the elliptic curve, but fails to verify that the constituent limbs respect their allocated bit-widths, allowing non-canonical proof representations. In the native Rust execution path, accumulator decoding relies on unchecked assertions and unwraps, allowing malformed public instances to trigger an unhandled process panic.

Amit Schendel
Amit Schendel
4 views•12 min read
•about 6 hours ago•CVE-2026-63496
7.8

CVE-2026-63496: OS Command Injection in @augment-vir/node grep() Helper

An OS command injection vulnerability (CWE-78) exists in the @augment-vir/node package prior to version 31.73.5. The grep() utility function builds a shell command string by interpolating caller-supplied search patterns inside double quotes and executes the string through bash via runShellCommand(). Because bash evaluates command substitution expressions inside double-quoted strings, an attacker controlling the search pattern input can execute arbitrary OS commands with the privileges of the Node.js runtime.

Alon Barad
Alon Barad
4 views•8 min read
•about 18 hours ago•CVE-2026-53998
10.0

CVE-2026-53998: Format String Injection and Information Disclosure in Arize Phoenix applyChatTemplate

CVE-2026-53998 is a critical format string injection vulnerability in Arize Phoenix affecting versions 13.0.0 prior to 15.7.0. The flaw resides in the applyChatTemplate GraphQL endpoint, which passes user-supplied template strings directly to Python's native str.format() method via FStringTemplateFormatter._format. Because attribute access is not restricted, an attacker can traverse Python dunder attributes (__class__, __init__, __globals__) to read arbitrary process memory and environment variables, including the PHOENIX_SECRET cryptographic key and third-party API credentials.

Amit Schendel
Amit Schendel
9 views•9 min read
•about 19 hours ago•CVE-2026-63634
6.9

CVE-2026-63634: EVM Calldata Padding Gas Drainage in pympp Fee-Payer Verification

CVE-2026-63634 is an improper input validation vulnerability (CWE-20) in pympp, the official Python SDK for the Machine Payments Protocol (MPP) developed by tempoxyz. In versions prior to 0.9.1, servers acting as transaction fee payers validate incoming Ethereum Virtual Machine (EVM) transaction calldata using minimum-length thresholds rather than exact byte-length assertions. Because EVM smart contract dispatchers ignore trailing unparsed bytes while the protocol charges intrinsic gas for every byte in a transaction payload, an unauthenticated attacker can append thousands of non-zero padding bytes to legitimate payment requests. The server cosigns and broadcasts the oversized transaction, forcing the fee-payer wallet to expend inflated gas costs up to the policy limit and depleting its native token reserves.

Amit Schendel
Amit Schendel
5 views•11 min read