/

CVE-2026-25561

Severity:

HIGH RISK

(7.5)

Authorization Logic Flaw in WeKan Attachment Upload API

CVE-2026-25561

Analyzed

Vulnerability type

Category:

Authorization Logic Flaw

CWE:

CWE-863

Impact:

Unauthorized Data Access / Integrity Impact

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 authorization logic weakness in the attachment upload API where supplied identifiers for boards, cards, swimlanes, and lists are not fully validated as a coherent set.

This can allow a user to attempt uploading attachments to cards or boards they should not have access to by exploiting mismatched object relationships in the request parameters.

Affected context

The vulnerability appears in the attachment upload functionality of WeKan when:

  • A user can send crafted API requests directly to the attachment upload endpoint.
  • The API accepts multiple related identifiers (boardId, cardId, swimlaneId, listId).
  • The backend does not strictly verify that all identifiers belong to the same, authorized card within a board the user may access.

It is most relevant in multi-user or multi-board deployments where users are expected to be isolated from each other's boards or specific cards.

Exploit preconditions

  • Attack surface: HTTP(S) attachment upload API for WeKan.
  • Required access: Ability to authenticate as a valid WeKan user and interact with the attachment upload endpoint.
  • Trigger point: Sending an attachment upload request where identifiers (boardId, cardId, swimlaneId, listId) are deliberately mismatched.
  • Why exploitation is possible: The server-side authorization logic checks do not fully enforce relational consistency between provided identifiers, resulting in insufficient validation that the target card/board hierarchy is both coherent and authorized for the calling user.

Why this happens

The root cause aligns with CWE-863: Incorrect Authorization and stems from incomplete authorization checks on compound object references.

Instead of deriving the target card and its context from a single authoritative source on the server, the API trusts multiple client-supplied identifiers and does not strictly ensure:

  • That the identifiers form a valid, existing card/board/list/swimlane relationship.
  • That the authenticated user is authorized for that specific combined context.

This pattern of partially validating identifiers allows cross-object confusion where attachments can be associated with resources outside the user's intended or permitted scope.

Potential impact

  • Attachment uploads may be associated with cards or boards the user should not be able to interact with.
  • Users could potentially influence or clutter other users' boards by attaching files to unauthorized locations.
  • In some configurations, this may assist in bypassing access controls around which cards or boards can receive new content.
  • If combined with other weaknesses, it could facilitate broader privilege misuse or information integrity issues.

General mitigation guidance

Effective mitigation focuses on strict, server-side authorization and relationship validation:

  • Resolve the target card or board using a single, minimal identifier and enforce all relationship checks on the server (e.g., derive list and swimlane from the card).
  • Validate that all supplied identifiers, if still required, map to a coherent and existing board–swimlane–list–card hierarchy.
  • Perform authorization checks after resolving the true target objects, ensuring the authenticated user has the appropriate permissions for that exact card and board.
  • Reduce reliance on client-supplied relational data and prefer server-side lookups using internal IDs associated with the user's session.
  • Apply the principle of least privilege so that attachment operations are only allowed on resources clearly owned or shared with the current user.

How teams detect issues like this

Detection typically involves reviewing both code and runtime behavior:

  • Static analysis / code review: Look for endpoints that accept multiple related identifiers (boardId, cardId, listId, etc.) and verify that:
  • The server recomputes or checks the full relationship among them.
  • Authorization decisions occur after relationship validation.
  • Policy checks: Enforce architectural rules that prohibit trusting client-side relationships and require server-side derivation of related objects where possible.
  • Runtime monitoring: Log attachment upload attempts with the resolved board/card context and monitor for patterns of mismatched or unauthorized associations.
  • Automated tools and manual reviews can be configured to flag API handlers where authorization is performed on incomplete or unverified object graphs.

Sources

SourceLink
github.comgithub.com/wekan/wekan/commit/1d16955b6d4f0a0282e89c2c1b0415c7597019b8
wekan.fiwekan.fi/
vulncheck.comvulncheck.com/advisories/wekan-attachment-upload-object-relationship-validation-bypass

Frequently asked

questions

No. The issue is limited to authorization around attachment uploads and object relationships; it does not directly provide credential theft or code execution, but it can affect where attachments are stored and associated.

An attacker typically needs to be an authenticated WeKan user with the ability to reach the attachment upload API and craft custom requests. They do not need administrative permissions, but they must have some valid account.

The safest pattern is to centralize authorization and relationship validation: derive the full target object hierarchy on the server from minimal identifiers, confirm it forms a valid relationship, and then verify that the authenticated user is permitted to perform attachment operations on that exact resource.

Design APIs so that authorization decisions are based on server-resolved objects, avoid trusting client-supplied relational links, enforce strict object graph validation, and incorporate automated checks and code review guidelines focused on compound authorization logic.

Find out what's already
exploitable in your codebase.