/

CVE-2026-35183

Severity:

HIGH RISK

(7.1)

Insecure Direct Object Reference (IDOR) in Brave CMS

CVE-2026-35183

Analyzed

Vulnerability type

Category:

Insecure Direct Object Reference (IDOR)

CWE:

CWE-639

Impact:

Unauthorized Resource Modification / Data Loss

Severity:

HIGH RISK

(7.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

Brave CMS contained an Insecure Direct Object Reference in its article image deletion feature, allowing authenticated editors to delete images by specifying a filename in the URL without proper ownership checks.

Under typical multi-user deployments, this could let one user remove media assets associated with other users' articles, impacting content integrity and availability.

Affected context

The vulnerability appears in Brave CMS instances where multiple users manage content and images through the dashboard.

It specifically affects the article image deletion path in app/Http/Controllers/Dashboard/ArticleController.php, where an authenticated user with edit permissions can invoke deleteImage by passing a filename in the URL.

The issue becomes relevant when different users share the same media storage area and the system does not enforce per-owner or per-article access controls on file deletion.

Exploit preconditions

  • Attack surface: HTTP(S) endpoint for deleting article images, exposed via the CMS dashboard.
  • Required access: Authenticated CMS account with sufficient privileges to edit or manage articles (no administrative role strictly required).
  • Trigger point: Calling the image deletion endpoint with a filename that belongs to another user's article.
  • Why exploitation is possible: The server accepts a raw filename identifier from the URL and performs the deletion without validating that the requesting user owns the associated article or image, enabling arbitrary deletion within the shared storage scope.

Why this happens

This issue stems from an authorization flaw consistent with CWE-639: Insecure Direct Object Reference, where internal identifiers (in this case, a filename) are used directly to locate a protected resource without verifying the caller's entitlement.

The deleteImage method treats the filename parameter as a trustworthy reference to a resource and only checks that the user is allowed to call the endpoint in general (e.g., has edit permissions), but not that they are allowed to act on that specific image.

Abstractly, the insecure pattern is: "accept user-controlled identifiers to sensitive objects and apply only coarse-grained role checks, omitting object-level access control," enabling horizontal privilege escalation between users at the same privilege level.

Potential impact

  • Unauthorized deletion of images attached to other users' articles.
  • Loss of media assets, potentially requiring restoration from backups.
  • Defacement or degradation of published content where images are integral to the article.
  • Disruption of editorial workflows and trust between tenants or user groups sharing the CMS.
  • Indirect damage to brand or user experience due to missing or broken images on public-facing pages.

General mitigation guidance

Effective mitigation focuses on implementing consistent, fine-grained authorization around object references rather than relying solely on role-based checks:

  • Introduce object-level access control: whenever a filename or media ID is supplied, resolve it to the associated article or owner and verify that the current user is permitted to manipulate that specific resource.
  • Avoid using unguarded raw identifiers from URL parameters; instead, map request parameters to database records where ownership and tenancy boundaries can be enforced.
  • Apply a standard authorization policy layer (e.g., policies, guards, middleware) around media operations so that checks are not re-implemented ad hoc per controller method.
  • Design media storage to reflect ownership boundaries (e.g., per-tenant or per-user namespaces) and validate that operations stay within the current user's namespace.
  • Follow the principle of least privilege, ensuring that edit or content-management roles only extend to resources that belong to the user, group, or tenant they are assigned to.

How teams detect issues like this

Detection typically combines code-level review and automated policy enforcement:

  • Static analysis and linters: Configure rules to flag controller actions or routes that:
  • Accept IDs or filenames from query/path parameters, and
  • Perform destructive operations (delete, update, move) without an accompanying ownership or policy check.
  • Code review checklists: Include explicit questions such as "Does this action enforce object-level authorization?" for all CRUD endpoints that operate on user-owned content or media.
  • Centralized authorization policies: Use a consistent authorization framework (e.g., policy objects, decorators, middleware) and scan for endpoints that bypass or disable these mechanisms.
  • Runtime monitoring: Log image deletion requests with user IDs, target filenames, and associated article IDs, then alert on suspicious patterns (e.g., one user deleting many resources owned by others).

Sources

SourceLink
github.comgithub.com/Ajax30/BraveCMS-2.0/security/advisories/GHSA-cpf3-fxwg-cwr3

Frequently asked

questions

Yes, if the Brave CMS dashboard is exposed over the internet and a user can authenticate, they can exploit the issue by crafting requests to the image deletion endpoint. However, it cannot be exploited by completely unauthenticated outsiders.

The attacker must have a valid Brave CMS account with permissions to edit or manage articles. From there, they can target image filenames associated with other users' articles.

The most robust fix is to enforce object-level authorization: whenever a user references an internal identifier (such as a filename or media ID), the application should resolve that reference to its owning entity and verify that the current user is allowed to act on that specific resource before performing any state-changing operation.

Adopt a standard access control model that treats all user-supplied identifiers as untrusted and requires explicit authorization checks tied to the resource being accessed. Integrate these checks into shared middleware or policy layers, enforce them in code review, and use automated tooling where possible to detect endpoints that manipulate user-owned resources without ownership validation.

Find out what's already
exploitable in your codebase.