Summary
Kanboard up to version 1.2.52 contains a broken access control issue in the drag-and-drop board endpoint, allowing users to move tasks outside their authorized projects.
Because the application validates the user against an attacker-supplied project_id but never confirms that the task_id belongs to that project, any authenticated user can enumerate and rearrange tasks from other projects, including private ones, when the instance uses globally sequential task IDs.
Affected context
This vulnerability appears in Kanboard instances where the BoardAjaxController save() method powers the kanban board drag-and-drop interface.
It becomes relevant when task identifiers are sequential across the entire instance and the endpoint relies solely on role checks for a caller-supplied project_id.
In such setups, any authenticated user with membership in at least one project may indirectly affect tasks in other projects if ownership validation between task_id and project_id is missing.
Exploit preconditions
- Attack surface: HTTP API used by the kanban board drag-and-drop (BoardAjaxController save() endpoint)
- Required access: Any authenticated Kanboard account with membership in at least one project
- Trigger point: Sending a request that references a project the attacker can access while specifying a task_id that actually belongs to a different project
- Why exploitation is possible: The endpoint verifies the user's role against the caller-supplied project_id but does not verify that the supplied task_id is owned by that project, and task IDs are globally sequential across the instance, enabling enumeration
Why this happens
The underlying bug is a form of broken access control where authorization checks are performed only on one resource attribute (project_id) and not on the related resource (task_id).
Concretely, the BoardAjaxController save() method ensures the caller has the appropriate role for the project they claim to be manipulating but fails to assert that the task being moved actually belongs to that project.
This pattern maps to CWE-639: Authorization Bypass Through User-Controlled Key, where attackers exploit user-controlled identifiers to gain unauthorized access or influence over other objects in the system.
Potential impact
- Authenticated users may move tasks belonging to other projects, including private projects
- Tasks from sensitive projects could be hidden, misclassified, or effectively corrupted on the board view
- Project workflows and reporting can be disrupted or manipulated
- Incident response and audit trails may be complicated due to unexpected cross-project task movements
General mitigation guidance
Effective mitigation focuses on enforcing strict ownership checks between related entities and reducing reliance on user-supplied identifiers for authorization decisions.
Common defensive patterns include:
- Validating that every task_id used in project-scoped operations is actually owned by the referenced project_id
- Centralizing authorization checks so that object-level access rules are consistently applied across controllers and endpoints
- Treating all client-controlled identifiers as untrusted and re-resolving them server-side before performing actions
- Designing APIs so that operations are scoped by server-resolved resource relationships rather than by loosely coupled IDs from the client
- Applying least-privilege design to ensure authenticated users can only manipulate tasks in projects they explicitly belong to
How teams detect issues like this
Detection typically involves reviewing how identifiers are used in authorization logic and verifying that object ownership checks are enforced.
High-level strategies include:
- Static analysis rules that flag uses of user-supplied IDs in access control decisions without corresponding ownership validation
- Code review checklists that require verifying the relationship between primary resources (projects) and secondary resources (tasks) in each endpoint
- Security-focused tests that attempt cross-project operations using valid credentials for one project and object IDs from another
- Automated tooling or policies that enforce consistent use of authorization helpers for object-level checks across the codebase

