Nov 18, 2026·9 min read·0 visits
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.
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.
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.
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 POSTIn 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.
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-123The 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.
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.
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:
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.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.
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
django-filer django-cms | < 3.5.0 (<= 3.4.4) | 3.5.0 |
| Attribute | Detail |
|---|---|
| CVE / GHSA ID | CVE-2026-69131 / GHSA-vf85-8ff2-3r9w |
| Weakness Class | CWE-862 (Missing Authorization) / CWE-639 |
| CVSS v3.1 Score | 4.3 Medium (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N) |
| Attack Vector | Network (Authenticated Staff User via Django Admin POST) |
| Preconditions | FILER_ENABLE_PERMISSIONS=True & Model-level delete_* permissions |
| Security Impact | Unauthorized deletion of files and folders in read-only directories |
| Exploit Status | PoC (Upstream regression test in PR #1605) |
| Patched Version | django-filer 3.5.0 |
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).
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.
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.
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.
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.
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.
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.