Summary
A broken object-level authorization vulnerability in Vikunja allows an authenticated user to access task data outside their permitted tenant or project context. By supplying another task identifier to affected task-bucket endpoints, an attacker may retrieve task contents and alter completion metadata when the selected bucket represents a completed state.
Affected context
The issue occurs in Vikunja deployments using the affected task-bucket routes before authorization is independently applied to the task object. The endpoint authorizes URL-based project, view, and bucket values but may not verify that the body-supplied task belongs to the requesting user or authorized tenant. Both API route families may be affected when they share the same task-bucket authorization model.
Exploit preconditions
- Attack surface: Authenticated HTTP API endpoints for task-bucket operations
- Required access: A valid user account and the ability to submit requests to an affected route
- Trigger point: A task-bucket request containing a caller-controlled task identifier
- Why exploitation is possible: Authorization is applied to container objects from the URL, while the referenced task is read and updated without a separate object-level permission check
- Additional condition: Predictable, sequential task identifiers may make unauthorized task references easier to discover
Why this happens
The underlying flaw is a missing object-level authorization check, mapping to CWE-639: Authorization Bypass Through User-Controlled Key. The handler trusts a task identifier supplied in the request body and validates only the project, view, and bucket represented in the URL. Because the task is subsequently read or modified without confirming that the caller can access that specific object, a valid user may operate on tasks outside the authorized scope.
Potential impact
- An attacker may read contents of tasks belonging to other users or tenants.
- An attacker could alter task completion metadata without proper authorization.
- Cross-tenant confidentiality boundaries may be weakened.
- Unauthorized status changes could disrupt workflows, reporting, or automation.
- Repeated exploitation may cause data integrity issues across projects.
General mitigation guidance
Mitigation generally focuses on enforcing authorization at the object being accessed or changed rather than relying on related URL parameters.
Common defensive patterns include:
- Performing an explicit permission and tenant-ownership check for every task identifier supplied by a client.
- Deriving object scope from the authenticated identity and trusted server-side relationships.
- Avoiding reliance on sequential identifiers as a security boundary.
- Applying identical authorization rules across all equivalent API route versions.
- Separating read and update authorization decisions and validating the requested state transition.
- Running regression tests for cross-project and cross-tenant access attempts.
How teams detect issues like this
Organizations can identify similar weaknesses through:
- Static analysis and code review searches for request-controlled identifiers passed directly to read or update operations.
- Review of handlers that authorize parent resources without checking the referenced child object.
- Tests that substitute identifiers from another user, project, or tenant while retaining otherwise valid request context.
- API gateway or service policies that log and alert on repeated access to sequential identifiers or authorization failures.
- Automated security testing that compares authorization behavior across API versions and equivalent endpoints.

