/

CVE-2026-55234

Severity:

HIGH RISK

(8.5)

Authorization Bypass (CWE-284) in Wekan Board Updates

CVE-2026-55234

Deferred

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-284, CWE-639

Impact:

Unauthorized Access to Private Board Content

Severity:

HIGH RISK

(8.5)

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

Wekan contains an authorization flaw in update handlers for cards, lists, and swimlanes, where access checks only consider the original board and not a new board specified in the update.

An authenticated user with write access to their own board can exploit this by moving items into private boards they do not belong to, effectively bypassing board membership restrictions.

Affected context

This vulnerability affects Wekan deployments where users can update cards, lists, or swimlanes via DDP or REST-like endpoints and where private boards coexist with boards users can modify.

The issue manifests in the server-side permission rules that authorize update operations based only on the stored boardId, without validating newly supplied boardId values in the update modifier.

Environments with multi-tenant teams, sensitive workstreams, or strict board-level privacy controls are more exposed, as cross-board moves may silently weaken isolation between boards.

Exploit preconditions

  • Attack surface: Application-layer endpoints, including /cards/update, /lists/update, and /swimlanes/update, exposed to authenticated users.
  • Required access: Valid authenticated account with write access to at least one board they control or are a member of.
  • Trigger point: Submission of an update request that changes the boardId of a card, list, or swimlane to a target private board where the attacker is not a member.
  • Why exploitation is possible: The server-side allow rules check authorization against the existing stored boardId only, and do not re-validate permissions against a newly supplied boardId in the update modifier.

Why this happens

The underlying issue is an access control design flaw where authorization is tied to the resource's original association, not to the resource's new target context.

In the affected Wekan permission code, allow rules confirm that a user can modify an object on its current board, but they omit a subsequent check that the same user is allowed to place that object onto the newly specified board.

This maps to CWE-284: Improper Access Control and is closely related to CWE-639: Authorization Bypass Through User-Controlled Key, because the attacker can supply a new boardId as a control point to cross security boundaries.

Potential impact

  • Unauthorized movement of cards, lists, or swimlanes into private boards the attacker is not a member of
  • Potential exposure of private board structure or metadata through side effects and activity trails
  • Pollution or manipulation of workflows on sensitive boards, potentially disrupting project management processes
  • Weakening of board-level isolation, which can erode trust in privacy guarantees across teams or tenants

General mitigation guidance

Effective mitigation centers on ensuring that every context change undergoes a fresh authorization check.

Common defensive patterns include:

  • Validating that the acting user has appropriate permissions on both the source and target boards whenever a resource moves across boards.
  • Treating any user-supplied identifiers (like boardId) as untrusted and re-resolving them through server-side permission checks before applying updates.
  • Implementing centralized authorization logic for move operations instead of spreading checks across multiple allow rules or handlers.
  • Restricting cross-board move capabilities to clearly defined workflows, minimizing generic "update-any-field" patterns for security-critical properties.
  • Applying least-privilege concepts to board roles so that even authorized moves have bounded impact within expected collaboration scopes.

How teams detect issues like this

Detection efforts can focus on both code and runtime behavior:

  • Static analysis and code review:
  • Look for update handlers where identifiers such as boardId, projectId, or similar context keys can be modified without a subsequent permission check against the new value.
  • Flag allow/deny rules that only reference the existing object state but ignore the update modifier or target context.
  • Enforce patterns where move operations use specialized APIs with explicit authorization, rather than generic update calls.
  • Runtime monitoring:
  • Log all cross-board move operations and periodically review for patterns where users move items into boards they do not belong to.
  • Use anomaly detection on authorization logs to surface unexpected context changes (e.g., items frequently entering highly restricted boards).
  • Policy enforcement:
  • Integrate automated security tests into CI pipelines that attempt unauthorized cross-board moves using test accounts, verifying that such requests are rejected.

Sources

SourceLink
github.comgithub.com/wekan/wekan/commit/d369a3614a4737c29d48a6345a790edf2506ddae
github.comgithub.com/wekan/wekan/releases/tag/v9.37
github.comgithub.com/wekan/wekan/security/advisories/GHSA-gm7v-pc38-53jr

Frequently asked

questions

Yes. Any remote authenticated user who can reach the Wekan instance and has write access to at least one board can exploit the issue through the exposed update endpoints.

The attacker must have a valid account and write permissions on their own board or any board they can modify. They do not need to be a member of the target private board they are moving items into.

Implement authorization checks that verify permissions on the target context (the new boardId) whenever a resource is reassigned or moved, and centralize this logic so all move operations follow the same strict rules.

Model authorization around actions and contexts rather than just resources, treat all identifiers in client-supplied payloads as untrusted, and enforce consistent, testable authorization policies for any operation that changes ownership, scope, or container relationships.

Find out what's already
exploitable in your codebase.