/

CVE-2026-52784

Severity:

HIGH RISK

(8.8)

CSRF Admin Privilege Escalation (CWE-352) in OpenProject

CVE-2026-52784

Deferred

Vulnerability type

Category:

Cross-Site Request Forgery (CSRF)

CWE:

CWE-352

Impact:

Privilege Escalation to Administrative Access

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 cross-site request forgery (CSRF) flaw in OpenProject allows an attacker to toggle the admin flag on a user account via a crafted POST request to /users/:id.

If a logged-in administrator is tricked into visiting a malicious page, their browser can silently submit this request, potentially granting admin rights to unintended users.

Affected context

The vulnerability arises in OpenProject's web-based user management interface when state-changing actions on /users/:id are accepted without robust CSRF protections.

It is most relevant in deployments where administrators manage user accounts through the standard web UI and where browsers can be induced to send authenticated requests to the application.

Exploit preconditions

  • Attack surface: Web interface endpoint /users/:id handling user updates via POST.
  • Required access: Attacker must cause a logged-in administrator (or user with rights to modify user[admin]) to visit a malicious page in a browser with an active OpenProject session.
  • Trigger point: Submission of a forged POST request containing the user[admin] parameter to the vulnerable endpoint.
  • Why exploitation is possible: The server does not consistently validate a CSRF token or equivalent anti-forgery mechanism, allowing the browser to reuse existing authentication cookies for unintended requests.

Why this happens

This issue stems from missing or ineffective CSRF protection on a sensitive state-changing operation, mapped to CWE-352.

The user update endpoint trusts authenticated requests based solely on session cookies, without verifying that the request originated from legitimate user interaction within the application.

As a result, an attacker can embed an auto-submitting form or script in a third-party page that causes the victim's browser to send a valid POST with user[admin] set, altering user privileges.

Potential impact

  • An attacker could grant administrative privileges to arbitrary user accounts.
  • Existing non-admin accounts may be converted into full administrators without consent.
  • Administrative control over projects, configurations, and user management can be obtained indirectly.
  • Further compromise of data integrity and confidentiality may follow from misuse of elevated accounts.

General mitigation guidance

Effective mitigation focuses on enforcing strong CSRF defenses around all state-changing endpoints, especially those that alter roles or privileges.

Common patterns include requiring unique, per-request CSRF tokens tied to the user session, validating these tokens on the server, and rejecting requests that lack them.

Complementary measures involve constraining which parameters can be modified by which roles, applying least-privilege role design, and confirming high-risk actions with explicit user interaction (e.g., re-authentication or confirmation dialogs).

How teams detect issues like this

Detection often begins with reviewing server-side handlers for sensitive actions to ensure they enforce CSRF token validation and do not rely solely on cookies.

Static analysis or security linters can flag form submissions and XHR requests that omit CSRF controls or middleware, especially on endpoints that change user roles.

Security testing, such as manual penetration tests or automated web scanners, can attempt to submit cross-origin POST requests to privileged endpoints and observe whether the server accepts these forged requests.

Sources

SourceLink
github.comgithub.com/opf/openproject/security/advisories/GHSA-6crw-7f5r-4qj9

Frequently asked

questions

Yes. An attacker can exploit it remotely by hosting a malicious webpage that triggers the forged request in a victim administrator's browser, as long as the victim is logged into OpenProject.

The attacker does not need direct access to OpenProject but must be able to lure a user with sufficient privileges (typically an administrator) into visiting a crafted page while logged in.

Apply robust CSRF protections on all state-changing endpoints, validating server-side tokens for each request, and ensure privilege-changing parameters are only processed when accompanied by valid anti-forgery tokens.

Standardize CSRF defenses via framework middleware, enforce security reviews for endpoints that modify roles or permissions, and adopt a policy that no state-changing action is allowed without validated CSRF tokens and appropriate authorization checks.

Find out what's already
exploitable in your codebase.