/

CVE-2026-56765

Severity:

CRITICAL RISK

(9.8)

Authorization Bypass (CWE-639) in Vikunja Sharing APIs

CVE-2026-56765

Deferred

Vulnerability type

Category:

Authorization Bypass / Insecure Direct Object Reference

CWE:

CWE-639

Impact:

Privilege Escalation and Instance-wide Data Exposure/Deletion

Severity:

CRITICAL RISK

(9.8)

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

Vikunja contains broken authorization checks that expose share hashes and allow attachment operations based on unvalidated identifiers.

Under certain conditions, users with basic read access can escalate to admin-level shares and download or delete file attachments across all projects on a vulnerable instance.

Affected context

This vulnerability manifests in Vikunja's API endpoints responsible for link sharing and task attachments.

It becomes relevant when:

  • Users can access the LinkSharing.ReadAll endpoint and see share metadata beyond their intended scope.
  • The GetTaskAttachment endpoint relies on user-supplied task IDs for permission checks but retrieves attachments by their own sequential IDs.

In environments where these endpoints are exposed to regular project users, the flawed authorization logic can lead to broader access than intended.

Exploit preconditions

  • Attack surface: Vikunja HTTP API, specifically link sharing and attachment-related endpoints.
  • Required access: Valid user account with at least read-level access to some projects or tasks.
  • Trigger points:
  • Calling LinkSharing.ReadAll to enumerate share hashes and associated data.
  • Invoking GetTaskAttachment and related attachment operations using crafted attachment IDs.
  • Why exploitation is possible:
  • The link sharing endpoint exposes share hashes to users who should not control or view admin-level shares, enabling escalation.
  • Attachment operations verify permissions against user-supplied task IDs but then act on attachments by globally sequential IDs without enforcing ownership, effectively creating an insecure direct object reference (IDOR) condition.

Why this happens

The core issue is broken object-level authorization, aligning with CWE-639: Authorization Bypass Through User-Controlled Key.

The link sharing endpoint returns sensitive share hashes to any user with read access, treating visibility as equivalent to management authority.

The task attachment endpoint trusts user-supplied task identifiers for the permission check but subsequently uses attachment IDs that are not bound to the user or project context, allowing access to any attachment on the instance.

Conceptually, the design fails to enforce authorization at the resource level (per share, per attachment) and instead relies on loosely related parameters, resulting in users being able to act on objects they do not own.

Potential impact

  • Users may escalate from read-level shares to admin-level shares using exposed share hashes.
  • Attackers could download arbitrary file attachments across all projects on the instance.
  • Sensitive documents and files can be exposed to unauthorized users.
  • Malicious users may delete attachments belonging to other projects, causing data loss and disruption.
  • Compromise of confidentiality, integrity, and availability of stored project files.

General mitigation guidance

Effective mitigation focuses on enforcing strict, resource-level authorization checks and minimizing exposure of sensitive identifiers.

Recommended patterns include:

  • Validating access per share object: ensure that listing or retrieving share hashes is restricted to principals that own or administratively control those shares.
  • Binding attachment operations to the authenticated user's accessible projects and tasks, enforcing checks on the actual attachment record rather than only on user-supplied task IDs.
  • Avoiding the exposure of powerful tokens or share hashes in broad listing endpoints; treat them as secrets with least-privilege visibility.
  • Implementing a consistent authorization layer that evaluates access based on the resource's owner, project, and permission model, rather than trusting client-provided IDs.
  • Applying defense-in-depth with role-based access control and limiting destructive operations (such as delete) to appropriate roles and contexts.

How teams detect issues like this

Detection can rely on both code-level and behavioral techniques:

  • Static analysis and manual review to identify endpoints where authorization checks depend on user-controlled IDs or where object ownership is not verified at the resource level.
  • Reviewing API handlers for list and read-all operations that expose tokens, hashes, or identifiers that can be used to control or access other objects.
  • Logging attachment and share operations (download, delete, update) with resource IDs and user identities, and monitoring for patterns where a single user accesses or deletes resources across many unrelated projects.
  • Implementing security tests (e.g., unit and integration tests) that simulate cross-project access attempts, ensuring that users are prevented from acting on objects they do not own.
  • Using automated API security scanners or authorization-focused tooling that flags insecure direct object references and missing ownership checks.

Sources

SourceLink
github.comgithub.com/go-vikunja/vikunja/security/advisories/GHSA-2pv8-4c52-mf8j
vulncheck.comvulncheck.com/advisories/vikunja-unauthenticated-instance-wide-data-breach-via-link-share-hash-disclosure-chained-with-cross-project-attachment-idor

Frequently asked

questions

The vulnerability is broadly exploitable in any Vikunja instance where regular users can reach the affected endpoints. A user with basic read access can potentially escalate permissions and interact with attachments belonging to other projects, making the impact instance-wide rather than limited to a single project.

An attacker typically needs a valid account with read access to at least one project or task. They do not need administrative privileges. Once authenticated, they can abuse the exposed share hashes and insecure attachment ID handling to reach resources they should not be able to access.

The safest fix is to enforce strict object-level authorization. Each share and attachment operation should verify that the authenticated user is authorized to access that specific resource, based on ownership and project permissions. Additionally, limit the visibility of share hashes to only those users who legitimately manage the share, and avoid using loosely related parameters as the basis for permission decisions.

Future APIs should adopt a consistent authorization model where every resource access is checked against the authenticated user and the resource's access control policy. Avoid trusting client-supplied identifiers without verifying ownership, treat tokens and share hashes as secrets, and incorporate security testing that specifically targets IDOR and broken authorization patterns. Centralized authorization middleware and clear access control requirements during design can significantly reduce the chance of such flaws.

Find out what's already
exploitable in your codebase.