/

CVE-2026-44224

Severity:

HIGH RISK

(8.8)

Improper Privilege Management in Wiki.js users.update

CVE-2026-44224

Analyzed

Vulnerability type

Category:

Improper Privilege Management

CWE:

CWE-269

Impact:

Privilege Escalation to Full Administrator

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 privilege escalation flaw in the Wiki.js users.update GraphQL mutation allows users with manage:users permission to arbitrarily change their own group memberships without validation.

By assigning themselves to the Administrators group, a moderator-level user can gain full site administrator privileges after re-authentication.

Affected context

This vulnerability affects Wiki.js instances that:

  • Expose the users.update GraphQL mutation
  • Delegate the manage:users permission to non-admin users (e.g., moderators)
  • Use group-based permissions where membership in a high-privilege group (e.g., Administrators, ID 1) confers system-level capabilities

The issue manifests when the GraphQL resolver accepts and persists arbitrary groups arrays for user accounts without validating group ownership or permissible assignments.

Exploit preconditions

  • Attack surface: Authenticated application API via GraphQL (users.update mutation)
  • Required access: A valid account with the manage:users permission (commonly granted to moderators or support staff)
  • Trigger point: Invocation of the users.update mutation with a crafted groups array containing a high-privilege group ID (e.g., groups: [1])
  • Why exploitation is possible: The resolver forwards the caller-supplied groups array directly to the data model without:
  • Validating that the requested groups are allowed targets
  • Checking ownership or scope of groups relative to the caller
  • Enforcing constraints preventing self-assignment to administrator-level groups

Why this happens

The core issue is improper privilege management and insufficient authorization checks at the business-logic layer.

The users.update GraphQL resolver assumes that any groups array provided by a caller with manage:users is legitimate, and it passes these values directly to the persistence layer.

This design conflates "may update user accounts" with "may assign any group," creating a horizontal-to-vertical privilege escalation path.

Conceptually, this maps to CWE-269: Improper Privilege Management, where the system fails to enforce appropriate authorization boundaries on privilege-bearing attributes such as group membership and role assignments.

Potential impact

  • A moderator-level user may promote their own account to the Administrators group.
  • An attacker with manage:users can gain manage:system or equivalent full site administrator capabilities.
  • Unauthorized modification of global configuration, integrations, and security settings may occur.
  • Elevation of other accounts to privileged groups can entrench attacker control.
  • Indirect impact on data confidentiality and integrity through unrestricted access to wiki content and system secrets.

General mitigation guidance

Effective mitigations focus on enforcing strict authorization checks and least-privilege role design for group assignments:

  • Introduce server-side validation for role and group changes, ensuring only highly trusted principals can assign or modify administrator-level groups.
  • Separate "manage user profile data" from "manage user privileges," using distinct permissions and code paths.
  • Enforce allowlists or policy rules that define which roles may assign which groups, preventing self-escalation.
  • Treat group membership as a sensitive security attribute and require additional checks (e.g., admin-only endpoints or secondary approval) when changing it.
  • Periodically review delegated permissions such as manage:users to ensure they do not implicitly grant access to privilege-bearing operations.

How teams detect issues like this

Detection typically combines code-level analysis with runtime monitoring:

  • Static analysis / code review:
  • Look for GraphQL resolvers or REST handlers that accept role/group/permission parameters and pass them directly to models without intermediate authorization checks.
  • Flag patterns where the same permission gate controls both general user management and high-privilege assignments.
  • Review business logic around group IDs or role names hard-coded as "admin," "root," or ID 1 to ensure additional safeguards exist.
  • Runtime and log analysis:
  • Monitor audit logs for group membership changes, especially self-assignments to administrator or system roles.
  • Alert on unusual spikes in privilege changes, or on privilege elevations followed closely by configuration changes.
  • Policy enforcement:
  • Apply security policies in CI/CD that require explicit review for any code modifying authorization, roles, or group-assignment behavior.
  • Use automated review tools that highlight high-impact authorization paths for manual inspection.

Sources

SourceLink
github.comgithub.com/requarks/wiki/security/advisories/GHSA-cq3g-mwrg-v2rv

Frequently asked

questions

Yes, if the Wiki.js instance is internet-facing and an attacker can obtain an account with the manage:users permission, they can exploit the issue through the GraphQL API without needing local access to the server.

The attacker must already hold an account with the manage:users permission, often granted to moderators or user administrators. Anonymous or basic users without this permission cannot directly exploit the users.update mutation for escalation.

The safest pattern is to centralize authorization for privilege-bearing operations, treating role and group changes as separate, highly sensitive actions. Only tightly controlled, admin-only paths should be able to assign or revoke high-privilege groups, with explicit checks that the caller is allowed to make such changes.

Design the authorization model with clear separation between general management and privilege assignment, enforce least privilege on delegated roles, and require explicit validation whenever security-critical attributes (roles, groups, permissions) are altered. Combine this with regular security reviews of access-control logic and automated checks that flag direct user-controlled changes to privilege-bearing fields.

Find out what's already
exploitable in your codebase.