/

CVE-2026-35182

Severity:

HIGH RISK

(8.8)

Missing Authorization in Brave CMS Role Update Endpoint

CVE-2026-35182

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Privilege Escalation to Super Admin

Severity:

HIGH RISK

(8.8)

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

A missing authorization check in Brave CMS's role update endpoint allows any authenticated user to change account roles without proper permission validation.

Under these conditions, an attacker can promote their own account to Super Admin, gaining full administrative control of the CMS instance.

Affected context

This vulnerability occurs in Brave CMS deployments where the /rights/update-role/{id} POST route is exposed to authenticated users but does not enforce a role-assignment permission check.

The affected context is environments where:

  • Users can authenticate and access the application dashboard
  • The role update route is reachable after login
  • Authorization is expected to be enforced via middleware (e.g., checkUserPermissions:assign-user-roles) but is not applied to this endpoint

It is most impactful in multi-user deployments where non-admin accounts exist and should not have administrative capabilities.

Exploit preconditions

  • Attack surface: Web application HTTP interface (Brave CMS backend).
  • Required access: Any valid authenticated user account (e.g., regular user, editor).
  • Trigger point: Sending a POST request to /rights/update-role/{id} targeting their own or another user's account.
  • Why exploitation is possible: The route responsible for updating user roles skips the intended authorization middleware that should verify assign-user-roles permissions, so the application trusts any authenticated caller to modify roles.

Why this happens

The underlying issue is a missing authorization control on a sensitive operation, aligned with CWE-862: Missing Authorization.

In Brave CMS, the /rights/update-role/{id} route is defined without attaching the checkUserPermissions:assign-user-roles middleware that enforces who may modify user roles.

As a result, the business rule "only privileged administrators can assign or change roles" is not enforced at the code level for that endpoint.

This reflects a common pattern where critical actions rely on global authentication but omit fine-grained, per-operation authorization checks tied to specific privileges.

Potential impact

  • Any authenticated user may escalate their privileges to Super Admin.
  • Unauthorized users could modify or revoke other users' roles, potentially locking legitimate admins out.
  • Attackers can gain full control over site content, configuration, and user management.
  • Compromise of sensitive data stored or managed by the CMS.
  • Use of the compromised CMS as a platform for further attacks (e.g., injecting malicious content, phishing pages, or defacements).

General mitigation guidance

Effective mitigation focuses on enforcing fine-grained authorization for all role and permission changes:

  • Ensure that all routes performing privileged actions, such as updating user roles, are protected by specific authorization middleware or policy checks, not just generic authentication.
  • Centralize authorization logic so that permission checks for role management are consistently applied across controllers and routes.
  • Implement least privilege principles: only designated administrator roles should possess the capability to assign or modify roles.
  • Treat role and permission updates as high-risk operations, and consider adding secondary safeguards such as administrative confirmation flows or activity logging and review.
  • Regularly audit routing and controller configurations to verify that every sensitive endpoint enforces the intended permission requirements.

How teams detect issues like this

Detection can rely on both code-level and runtime analysis:

  • Static analysis and code review:
  • Review route declarations (e.g., in routes/web.php) to ensure every action that changes roles, permissions, or accounts has corresponding authorization middleware or policy checks.
  • Look for endpoints that modify user objects, roles, or permissions but only verify authentication and not explicit role/permission claims.
  • Enforce coding standards that require explicit authorization annotations or middleware for any role/permission-changing function.
  • Automated tooling:
  • Use SAST tools or custom linters to flag routes tagged as "administrative" that lack specific authorization middleware.
  • Integrate policy-as-code checks in CI/CD that fail builds when sensitive actions are not guarded by expected policies.
  • Operational monitoring:
  • Monitor logs for unusual role change activity, such as non-admin users invoking role update endpoints or a spike in promotions to high-privilege roles.

Sources

SourceLink
github.comgithub.com/Ajax30/BraveCMS-2.0/security/advisories/GHSA-g58h-mvjw-f4hv

Frequently asked

questions

Yes, it is remotely exploitable over the web interface, but the attacker must first have valid credentials to authenticate to the Brave CMS instance.

Any authenticated user account is sufficient. Once logged in, the attacker can send crafted requests to the role update endpoint to modify roles, including promoting themselves to Super Admin.

The safest approach is to enforce explicit authorization for all role and permission management operations by attaching appropriate permission-checking middleware or policies to the affected route and verifying that only designated administrative roles can change user roles.

Adopt a consistent access control model where every sensitive endpoint:

  • Is identified as such during design,
  • Requires explicit role/permission checks (not just authentication),
  • Is covered by automated tests and policy checks ensuring authorization is not accidentally omitted when routes or controllers are added or modified.
Find out what's already
exploitable in your codebase.