Your RSA-2048 keys break in 2030. Find every one of them before attackers do.
🐹 Go
Not in CISA KEV

Vikunja: API token scopes bypassed via task expand parameter (comments, reactions, time entry counts)GHSA-9rg3-v78m-26q8

Fix: go-vikunja/vikunja#3688

GHSA-9rg3-v78m-26q8 is a CWE-863 vulnerability in code.vikunja.io/api. A fix is available for code.vikunja.io/api — see the affected versions and patch details below.

Also known asCVE-2026-91983GO-2026-6726
Published
Updated
Affected
1 pkg
Patched
1 / 1
Exploits
None indexed
Exploitation data as of Oct 23, 2026 · OSV.dev, NVD, FIRST.org (EPSS)

Exploitation Status

Proof-of-concept exploit code exists

  • CISA’s SSVC triage found public proof-of-concept exploit code for this CVE, though no confirmed active exploitation.

Exploitation and automatability from CISA’s SSVC triage for GHSA-9rg3-v78m-26q8.

EPSS Exploitation Probability

via FIRST.org ↗
0.3%probability of exploitation in next 30 days
Lower Risk0.00%
Lower risk than most CVEs22th percentile — riskier than 22% of all scored CVEsHighest risk
0.00%0.27%0.54%0.80%0.3%0.3%Oct 26Oct 26

Probability of exploitation in the next 30 days, from FIRST.org EPSS.

Real-World Exposure

1 pkg affected
🐹code.vikunja.io/api

Real-time download stats are indexed for npm and PyPI packages. This vulnerability affects Go packages — download data is not available via public APIs for these ecosystems.

Description

Summary

API token permission checks only match the HTTP method and route path. The expand query parameter on task read endpoints embeds data from other permission groups (task comments, reactions, time entry counts) without checking whether the token holds those scopes. A token scoped only to tasks read permissions can therefore read task comments and reactions it was explicitly not granted.

Details

models.CanDoAPIRoute (pkg/models/api_routes.go, ~line 440) authorises API tokens purely by comparing method and c.Path() against the routes stored for each granted permission group. The query string is never consulted.

The task read endpoints accept expand:

  • GET /api/v1/tasks/:task, GET /api/v1/tasks (pkg/models/tasks.go ReadOne/ReadAll, pkg/models/task_collection.go)
  • GET /api/v2/tasks/:id, GET /api/v2/tasks, GET /api/v2/projects/:project/tasks (pkg/routes/api/v2/tasks.go, task_collection.go)

Accepted values include comments, comment_count, reactions, time_entries_count. addMoreInfoToTasks (pkg/models/tasks.go, ~line 683) loads and embeds that data. At that layer only a web.Auth (the plain owner user, resolved by auth.GetAuthFromClaims) is available, so the token's scopes cannot be enforced there either.

Result: the tasks_comments, reactions, and time_entries permission groups are advisory for any data reachable through a task expansion.

Impact

A holder of an API token scoped to tasks: [read_one] or tasks: [read_all] (or projects_views_tasks: [read_all]) can read the full bodies of task comments, all reactions, and time entry counts on every task the token owner can access, despite GET /api/v1|v2/tasks/:task/comments and the reactions endpoints correctly returning 401 for the same token.

The leak is limited to data the token owner can already see, and is read-only. The realistic victim is a user who grants a narrowly scoped token to a third-party integration expecting comments to stay private.

Proof of Concept

Against the test fixtures (pkg/db/fixtures/api_tokens.yml, token 1 has {"tasks":["read_all","update"]}, plaintext tk_2eef46f40ebab3304919ab2e7e39993f75f29d2e):

GET /api/v2/tasks/1/comments
Authorization: Bearer tk_2eef46f40ebab3304919ab2e7e39993f75f29d2e
-> 401 {"code":11,"message":"missing, malformed, expired or otherwise invalid token provided"}

GET /api/v2/tasks?expand=comments&filter=id%3D1
Authorization: Bearer tk_2eef46f40ebab3304919ab2e7e39993f75f29d2e
-> 200, response items[0].comments contains the full comment objects

Same behaviour with expand=reactions, and on the v1 endpoints GET /api/v1/tasks?expand=comments / GET /api/v1/tasks/1?expand=comments. Any user-created token with only tasks read permissions reproduces this.

Recommended Fix

Enforce expansions in the single existing choke point, models.CanDoAPIRoute: after the method/path match succeeds, read c.QueryParams()["expand"] and require the token to hold the owning group's read permission for each value, e.g.

  • comments, comment_count -> tasks_comments.read_all
  • reactions -> reactions.read_all
  • time_entries_count -> time_entries.read_all

(subtasks, buckets, is_unread are task-level data and need nothing extra.) Doing this in the middleware covers both v1 and v2 without handler or model changes. Add a table-driven test alongside pkg/webtests/api_token_method_matching_test.go asserting a tasks-only token gets 401 with expand=comments and 200 once tasks_comments.read_all is added.

Affected Packages

1 total 1 fixed
EcosystemPackageVulnerable rangeFix
🐹Gocode.vikunja.io/api≥ 1.0.0&&< 2.6.02.6.0go get code.vikunja.io/api@v2.6.0

Detection & mitigation playbook

Open-source dependency
  1. Detect

    Scan your dependency tree (package-lock.json, pnpm-lock.yaml, requirements.txt, go.sum, etc.) for code.vikunja.io/api, including transitive dependencies — a direct dependency you never call can still pull in a vulnerable version.

  2. Fix

    Update code.vikunja.io/api to 2.6.0 or later, then make sure no transitive (indirect) dependency still pins the vulnerable range — O3 confirms GHSA-9rg3-v78m-26q8 is resolved across your whole dependency graph.

  3. Workarounds

    Put an independent control in front of the weakness: restrict the affected endpoint or interface to trusted networks, require an additional authentication factor or proxy-level check, and invalidate existing sessions and credentials in case the flaw has already been used.

Frequently Asked Questions

## Summary API token permission checks only match the HTTP method and route path. The `expand` query parameter on task read endpoints embeds data from other permission groups (task comments, reactions, time entry counts) without checking whether the token holds those scopes. A token scoped only to `tasks` read permissions can therefore read task comments and reactions it was explicitly not granted. ## Details `models.CanDoAPIRoute` (`pkg/models/api_routes.go`, ~line 440) authorises API tokens purely by comparing `method` and `c.Path()` against the routes stored for each granted permission g
O3 Security · Impact-Aware SCA

Is GHSA-9rg3-v78m-26q8 in your dependencies?

Find it across Go, including transitive dependencies.

Vikunja: API token scopes bypassed via task expand…