/

CVE-2026-32817

Severity:

CRITICAL RISK

(9.1)

Missing Authorization / Broken Access Control

CVE-2026-32817

Analyzed

Vulnerability type

Category:

Missing Authorization / Broken Access Control

CWE:

CWE-862

Impact:

Unauthorized Data Deletion and Content Destruction

Severity:

CRITICAL RISK

(9.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Admidio's Documents & Files module from versions 5.0.0 through 5.0.6 exposes a critical access control flaw where delete operations on folders and files are not properly authorized.

Because deletion is allowed after only a view permission check and can be triggered via plain HTTP GET without CSRF protection, attackers may permanently remove documents, including in some cases without authentication.

Affected context

This vulnerability occurs in Admidio installations that have the Documents & Files module enabled, particularly when:

  • documents_files_module_enabled = 1 (module in public mode), and
  • One or more folders are marked as public (fol_public = true).

In this configuration, anonymous visitors can reach document URLs exposed by the module.

Even when the module is configured to require login, any authenticated user granted only view permissions over documents can still reach the affected handlers.

The vulnerable behavior is present in the folder_delete and file_delete actions of modules/documents-files.php, which treat deletion as if it required only read access.

Exploit preconditions

  • Attack surface: HTTP(S) interface to the Admidio web application.
  • Required access (public mode): None; an unauthenticated user can exploit the issue when:
  • The Documents & Files module is enabled in public mode.
  • Target folders are marked public.
  • Required access (login-required mode): Any authenticated account with only view permission to the target folder or file.
  • Trigger point: A crafted HTTP GET request to the folder_delete or file_delete actions in modules/documents-files.php, passing the target folder or file UUID in query parameters.
  • Why exploitation is possible:
  • The code only checks whether the current user can view (getFolderForDownload / getFileForDownload) rather than verifying a distinct delete permission.
  • There is no server-side verification of a CSRF token for these deletion endpoints.
  • The use of plain GET parameters ($_GET) to drive state-changing operations allows deletions to be triggered directly and also opens the door to CSRF from external sites.

Why this happens

The underlying bug is a missing authorization check for a sensitive operation, mapping to CWE-862: Missing Authorization.

The application conflates read and delete capabilities by reusing view-oriented helper methods (getFolderForDownload, getFileForDownload) to gate deletion, and never enforces a separate "may delete" policy.

Additionally, the deletion endpoints are implemented as idempotent-looking GET requests that change server state without any CSRF token validation.

This combination of broken access control and unsafe method semantics allows any user able to load a folder or file (including unauthenticated users when content is public) to invoke delete() on those resources.

Potential impact

  • An unauthenticated attacker may permanently delete all files and folders in public document libraries.
  • Authenticated users with view-only permissions can delete documents and folders they should only be able to read.
  • Loss of critical organizational documents, archives, and media assets.
  • Denial of service to users reliant on the document library for daily operations.
  • Potential reputational damage and compliance issues due to unexpected data destruction and poor access control practices.

General mitigation guidance

Effective mitigation focuses on enforcing strict, operation-specific authorization and aligning HTTP semantics with security expectations:

  • Introduce explicit permission checks for delete operations that verify a "delete" or "manage" capability distinct from "view" permissions.
  • Require state-changing actions (like deletion) to use non-GET methods (e.g., POST/DELETE) coupled with validated anti-CSRF tokens.
  • Centralize authorization decisions in a dedicated access control layer, ensuring that each sensitive action maps to a clearly defined policy rule.
  • Apply the principle of least privilege so that default roles receive read-only access without any modification or deletion rights.
  • Harden public-facing modules by treating "public view" as strictly read-only, with all modification actions gated behind authenticated and authorized roles.
  • Consider soft-delete or trash mechanisms so accidental or unauthorized deletions can be detected and reversed more easily, reducing impact even if a defect occurs.

How teams detect issues like this

Organizations can detect similar issues using a combination of code-focused and runtime approaches:

  • Static analysis / code scanning:
  • Flag controller or handler actions that invoke destructive methods (e.g., delete(), remove(), destroy()) without preceding authorization checks.
  • Detect state-changing operations exposed via HTTP GET methods.
  • Identify endpoints that handle delete operations but lack CSRF validation logic.
  • Code review practices:
  • Require reviewers to confirm that each CRUD operation (Create, Update, Delete) has a clearly documented and enforced permission requirement separate from "view".
  • Inspect modules that handle "public" resources to verify that public access implies read-only semantics.
  • Policy and automated tests:
  • Add integration tests that simulate low-privilege users (or unauthenticated clients) attempting deletion, modification, or administrative actions.
  • Configure web application firewalls (WAF) or reverse proxies with rules that alert on deletion-like actions via GET requests or from unauthenticated sessions.
  • Monitoring and logging:
  • Log all delete operations with user identity, source IP, and resource identifiers, and alert on unusual spikes or deletions from unexpected roles or anonymous users.

Sources

SourceLink
github.comgithub.com/Admidio/admidio/security/advisories/GHSA-rmpj-3x5m-9m5f

Frequently asked

questions

Yes. If the Admidio instance is exposed over the internet and the Documents & Files module is enabled in public mode with public folders, an unauthenticated remote attacker can exploit it by sending crafted HTTP GET requests.

Not necessarily. In public mode with public folders, no credentials are required. In login-required configurations, any user with mere view permissions over a folder or file can still exploit the flaw to delete content.

The safest pattern is to enforce explicit, operation-specific authorization checks for every sensitive action (such as deletion) and ensure such actions use non-GET methods protected by CSRF tokens. Authorization logic should be centralized and tied to a clear permission model that distinguishes between read, write, and administrative operations.

Prevention typically involves adopting a defense-in-depth approach: design a robust role- and permission-model, centralize authorization decisions, require security reviews for endpoints that modify or delete data, ban state-changing operations over GET, and integrate automated tests and static analysis rules that specifically look for missing authorization and CSRF validation on sensitive routes.

Find out what's already
exploitable in your codebase.