Summary
Vikunja link-share read endpoints may disclose a share's secret hash to users who should only have read-only access. An attacker could exchange the exposed credential for a link-share JWT and use the resulting permissions to perform unauthorized writes or administrative actions.
Affected context
The issue affects Vikunja deployments using link shares and single-share read endpoints. It becomes risky when a read-only member can retrieve the link-share hash field and the disclosed value can be converted into an authenticated link-share token with broader permissions.
Exploit preconditions
- Attack surface: Link-share single-share read endpoints
- Required access: An account or session with read-only member access to the relevant share
- Trigger point: A response that exposes the link-share hash field
- Why exploitation is possible: The hash functions as a secret credential that can be exchanged for a link-share JWT at the share's permission level
Why this happens
The vulnerability results from inadequate authorization and response filtering for a sensitive credential field. A read endpoint returns the link-share hash to a principal who is permitted to view share data but is not authorized to obtain credentials that can be reused for token issuance.
This behavior maps to CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, because a secret value is disclosed beyond its intended trust boundary. The underlying insecure pattern is treating credential-bearing metadata as ordinary read-accessible resource data.
Potential impact
- An attacker may obtain a reusable link-share credential.
- An attacker could obtain a link-share JWT with the share's configured permissions.
- Unauthorized users may create, modify, or delete data when write access is granted.
- An attacker could perform administrative actions within the scope of the exposed share.
- Sensitive project or task data could be altered, disrupted, or improperly disclosed.
General mitigation guidance
Mitigation generally focuses on separating resource visibility from credential visibility and enforcing authorization at every response boundary.
Common defensive patterns include:
- Excluding link-share hashes, tokens, and other credential material from ordinary read responses.
- Applying field-level authorization based on the caller's role and intended operation.
- Treating share secrets as opaque credentials rather than user-readable metadata.
- Issuing narrowly scoped, short-lived tokens with least-privilege permissions.
- Rotating or revoking exposed share credentials when disclosure is suspected.
- Avoiding privilege expansion when exchanging share credentials for session tokens.
How teams detect issues like this
Organizations commonly detect this class of issue through:
- Static analysis and API schema checks for sensitive fields returned by read endpoints.
- Code review searches for share hashes, tokens, secrets, or credential fields included in serializers and DTOs.
- Authorization tests that compare responses across anonymous, read-only, editor, and administrative roles.
- API gateway or policy rules that prevent credential-bearing fields from leaving trusted management interfaces.
- Audit monitoring for link-share token issuance followed by unexpected writes or administrative actions.
Automated API security testing and code review tools may help identify excessive data exposure and broken field-level authorization.

