Summary
WeKan versions prior to 8.19 contain an insecure direct object reference (IDOR) in checklist creation and related checklist routes, where the application does not confirm that a given cardId actually belongs to the specified boardId.
By tampering with identifiers in requests, an attacker who can access one board may be able to interact with or affect cards on other boards they should not control.
Affected context
This vulnerability appears in WeKan's checklist functionality, specifically in routes that create or manipulate checklists associated with cards.
It manifests when the server trusts client-supplied cardId and boardId combinations without validating their relationship or enforcing consistent authorization checks.
The issue is most relevant in multi-board deployments where different boards have different owners, members, or permission boundaries.
Exploit preconditions
- Attack surface: HTTP API and web UI endpoints related to checklist creation and checklist operations.
- Required access: Ability to authenticate and interact with at least one board and card (e.g., a regular user account).
- Trigger point: Sending a request where cardId is deliberately chosen from another board while supplying a boardId the attacker legitimately accesses.
- Why exploitation is possible: The server-side logic checks that the user can act on the given boardId but does not ensure that the referenced cardId actually belongs to that board, enabling cross-board ID tampering.
Why this happens
The root cause is a missing or incomplete authorization check on object relationships, aligned with CWE-639: Insecure Direct Object Reference.
Instead of deriving object access from server-side state, the implementation accepts client-supplied identifiers (boardId and cardId) and validates them in isolation, if at all.
Because the code does not confirm that the cardId is owned by, or associated with, the supplied boardId under the current user's permissions, attackers can forge requests that bind operations on cards from other boards into contexts they control.
Potential impact
- An attacker may create or modify checklists on cards that belong to boards they should not access.
- Sensitive task details or workflow structures on other boards could be exposed indirectly through checklist-related metadata.
- Integrity of project data on separate boards can be impacted through unauthorized checklist additions or edits.
- Confusion or mis-routing of work items can occur if cross-board manipulation is abused at scale.
General mitigation guidance
Mitigation generally requires enforcing strong, relationship-aware authorization checks on all object references:
- Ensure server-side logic derives the accessible objects from authenticated user context and internal relationships, rather than trusting arbitrary IDs from the client.
- When processing checklist routes, confirm that the referenced cardId belongs to the boardId and that the current user has appropriate permissions on that specific card and board.
- Use centralized authorization utilities or middleware that consistently validate both object ownership and object-to-object relationships (e.g., card-to-board).
- Reduce reliance on composite IDs in client requests where possible, instead looking up dependent objects on the server based on a single trusted parent resource.
- Apply the principle of least privilege in the permission model so that actions on checklists map tightly to board and card membership.
How teams detect issues like this
Detection typically combines code-centric and behavior-centric approaches:
- Static analysis / code review: Search for routes that accept multiple related IDs (e.g., boardId and cardId) and verify that they perform relationship checks (e.g., querying cards by both cardId and boardId and validating user access).
- Authorization design review: Inspect checklist-related controllers or services to confirm that authorization is applied at the card level, not only at the board level.
- Logging and anomaly detection: Monitor for requests where cardId and boardId combinations do not match expected relationships, such as cards being operated on under boards they do not belong to.
- Automated testing: Add security-focused integration tests that attempt cross-board operations by reusing valid card IDs from one board in the context of another board to ensure they are rejected.

