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
boardIdof 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
boardIdonly, and do not re-validate permissions against a newly suppliedboardIdin 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.

