/

CVE-2026-25563

Severity:

HIGH RISK

(7.5)

Insecure Direct Object Reference (IDOR) in WeKan Checklist

CVE-2026-25563

Analyzed

Vulnerability type

Category:

Insecure Direct Object Reference (IDOR)

CWE:

CWE-639

Impact:

Unauthorized Access to Cross-Board Cards and Checklists

Severity:

HIGH RISK

(7.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 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.

Sources

SourceLink
github.comgithub.com/wekan/wekan/commit/5cd875813fdec5a3c40a0358b30a347967c85c14
wekan.fiwekan.fi/
vulncheck.comvulncheck.com/advisories/wekan-checklist-creation-cross-board-idor

Frequently asked

questions

Yes. Any user who can reach the WeKan web interface or API and has credentials to access at least one board could potentially exploit the issue by manipulating identifiers in HTTP requests.

The attacker typically needs a valid user account with access to at least one board or card. From there, they can attempt to reuse or guess card identifiers that belong to other boards, relying on the insufficient relationship checks on the server.

Implement strict, server-side authorization that verifies both object ownership and relationships: for each checklist operation, ensure the cardId is loaded in the context of the provided boardId and confirm that the current user has permission to interact with that specific card. Centralizing these checks in a common authorization layer helps avoid inconsistencies.

Adopt a design where object references are validated server-side based on authenticated context, avoid trusting composite IDs from clients, and require all controller or route handlers to use shared authorization helpers. Additionally, integrate security code review, automated tests for access control, and policy-based checks into the development pipeline to catch missing relationship validations early.

Find out what's already
exploitable in your codebase.