Skip to main content

KeePassXC CVE-2026-118673

| EUVDEUVD-2026-113213 MEDIUM
Out-of-bounds Write (CWE-787)
2026-10-29 GitHub_M
4.1
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Reach per-user browser IPC endpoint
  2. Delivery
    Establish valid database association (test-associate)
  3. Exploit
    Request oversized authorized response from unlocked DB
  4. Execution
    Trigger out-of-bounds write in crypto_box_easy
  5. Impact
    Crash KeePassXC process (denial of service)

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Privilege Escalation

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires a local client that can reach KeePassXC's per-user browser IPC endpoint (the per-user named pipe/socket), possess a valid database association key (a completed test-associate/change-public-keys handshake), and face an already-unlocked database. Additionally, a sufficiently large authorized response must be generated - concretely demonstrated with ~180 matching entries carrying ~8 KiB titles so the encrypted ciphertext exceeds the fixed NATIVEMSG_MAX_LENGTH of 1,048,576 bytes (crossover observed near 8,161-character titles). The overflow is built only after the relevant entries are authorized: this happens automatically when Browser/AlwaysAllowAccess=true or when entries were previously approved, but under the DEFAULT policy (AlwaysAllowAccess=false) KeePassXC awaits interactive user approval and the process survives if approval is withheld - a significant real-world limiter. The practically meaningful scenario is a compromised or malicious but already-authorized browser extension that is sandboxed from the native process; a native-privilege attacker could terminate KeePassXC directly, so the added DoS value there is marginal.

Impact

The input CVSS 4.0 vector (AV:L/AC:H/AT:P/PR:L/UI:P/VC:N/VI:N/VA:H) yields a base score of 4.1 (MEDIUM), and the signals are internally consistent for a low-to-moderate priority issue rather than an urgent one. Multiple barriers stack: the attack vector is local to the per-user browser IPC endpoint (AV:L), it requires a valid database association (PR:L), it depends on specific heap/response conditions and user-approval timing (AC:H plus AT:P), and the only impact is availability (VA:H) - the reporter explicitly observed no confidentiality or integrity impact. The confirmed outcome is a reliable KeePassXC process crash/denial of service; the reporter, after a Microsoft CDB assessment, expressly did NOT claim RCE, instruction-pointer control, or credential disclosure. There is no CISA KEV listing (so this is not confirmed actively exploited) and no EPSS score was provided in the input, so exploitation probability cannot be quantified here. The vuln.today decision label is 'this_month' - a routine patch priority, not act_now or emergency. A detailed public PoC/reproduction methodology exists in the GHSA advisory, but the stated impact ceiling is DoS, and in the most security-relevant scenario (a sandboxed, already-authorized browser client that cannot otherwise touch the native process) the realistic gain is only crashing KeePassXC. Overall this is a genuine memory-safety defect but a bounded one, better characterized as medium-severity DoS than a high-risk emergency.

Exploit ScenarioDerived

A malicious or compromised browser extension (or other client that can reach the per-user KeePassXC named-pipe/IPC endpoint) that already holds a valid association key and faces an unlocked database issues a get-logins request whose authorized response is large enough - e.g. many matching entries with multi-kilobyte titles - that the encrypted output exceeds the fixed 1 MiB buffer. KeePassXC's crypto_box_easy() call then performs a sequential out-of-bounds write while building the response, reaching a reserved no-access page and crashing the process (0xC0000005) before any response is returned. A public PoC reference with full reproduction steps exists in the GHSA advisory; it is not published as a ready-to-run weaponized exploit, and the demonstrated impact is denial of service only.

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

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

Alert me

AnalysisAIv1 – Oct 29, 2026

Out-of-bounds heap write in KeePassXC's browser integration (versions 2.3.0 through 2.7.12) lets a local client that already holds a valid database association key crash the KeePassXC process while a database is unlocked, producing a reliable denial of service. The flaw is a fixed 1 MiB ciphertext buffer in BrowserMessageBuilder.cpp that is not resized or rejected when Botan's crypto_box_easy() must write plaintext length plus 16 MAC bytes, so a sufficiently large authorized response (reproduced with roughly 180 matching entries carrying ~8 KiB titles, crossing over near 8,161-character titles) writes sequentially past the buffer. The reporter reproduced a deterministic 0xC0000005 access violation inside botan-3.dll under Microsoft CDB using the official 2.7.12 Windows build, so a public proof-of-concept reproduction exists; it is not verified as weaponized exploit code beyond a crash, there is no CISA KEV entry, and impact is assessed as availability-only (CVSS 4.0 base 4.1, MEDIUM; independent vector AV:L/AC:H/PR:L/UI:R with C:N/I:N/A:H). The overflow is built only after entries are authorized, so the default AlwaysAllowAccess=false policy requires interactive user approval and the process survives if approval is withheld.

RemediationAI

Vendor-released patch: upgrade KeePassXC to 2.8.0 (https://github.com/keepassxreboot/keepassxc/releases/tag/2.8.0), which is the first version containing the fix from PR 13679 and commit 80e68bb; consult advisory GHSA-3448-gh8j-3227 for the vendor's wording. There is no separately documented workaround in the supplied data beyond the fix, but the reproduction shows concrete limiters: keep the default browser access policy Browser/AlwaysAllowAccess=false and do not pre-approve large sets of entries for browser access, since the oversized response is only built after entries are authorized and withholding interactive approval kept the process alive in testing (trade-off: a browser request then blocks on the approval dialog and the extension times out). Disabling browser integration entirely removes the per-user IPC endpoint that a malicious or compromised extension must reach (trade-off: loss of browser autofill). Because the practical threat model is a compromised but already-associated browser extension, audit and prune stored browser associations and avoid associating extensions you do not fully trust; note that a process already running with the same user's privileges could simply terminate KeePassXC, so these controls only reduce exposure for sandboxed clients rather than eliminating the crash.

Affected VersionsENISA

KeePassXC 2.3.0, < 2.8.0

Affected Packages

euvd keepassxc fix: 2.8.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

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

Technical ContextAI · show details

KeePassXC's browser protocol bridge encrypts responses for the browser extension using libsodium-compatible primitives exposed through Botan (Botan::Sodium::crypto_box_easy / crypto_secretbox_detached in botan-3.dll). In src/browser/BrowserMessageBuilder.cpp the caller allocates std::vector<unsigned char> e and resizes it to NATIVEMSG_MAX_LENGTH (1024*1024, defined in src/browser/BrowserShared.h), then calls crypto_box_easy(e.data(), ..., m.size(), ...). The primitive's contract requires an output buffer of plaintext_length + crypto_box_MACBYTES (16), so any plaintext longer than 1,048,560 bytes overruns the vector; because crypto_box_MACBYTES is a compile-time constant the required size is never validated or reallocated. This is CWE-787 (out-of-bounds write) in its simple sequential-heap form: debugger evidence shows a 16-byte movdqu store walking past a committed 0x101000-byte VirtualAlloc block into the adjacent MEM_RESERVE guard page, faulting while RIP is still inside Botan's crypto_box_detached/crypto_secretbox_detached frames. No return-address corruption, indirect-call-target control, instruction-pointer hijack, credential disclosure or RCE was observed, so severity is availability-only. The pattern dates to commit 06518c5 (2017-12-12) and therefore affects at least 2.3.0 through 2.7.12. The decrypt path uses a similar fixed 1 MiB vector with NUL-terminated length derivation, but that path is treated as defense-in-depth because no equivalent externally reachable overwrite was established through the outer JSON/Base64 IPC limits. Reaching the vulnerable code requires access to the per-user IPC endpoint (per-user Windows named pipe or local socket), a completed change-public-keys/test-associate handshake, an unlocked database, and an oversized authorized response; PR 13679 additionally reworks BrowserHost socket parsing and buffer sizing (NATIVEMSG_MAX_LENGTH replaced by SOCKET_BUFFER_SIZE with fragmented/coalesced message handling).

Know when Keepassxc gets its next vulnerability

  • 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 (GitHub_M) PRIMARY 4.1 MEDIUM
CVSS:4.0/AV:L/AC:H/AT:P/PR:L/UI:P/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
vuln.today AI 4.4 MEDIUM

Local per-user IPC endpoint gives AV:L; a valid association key is required so PR:L; a specific oversized response plus heap layout gives AC:H; approval timing gives UI:R; impact is crash-only, so C:N/I:N/A:H.

3.1 AV:L/AC:H/PR:L/UI:R/S:U/C:N/I:N/A:H
4.0 AV:L/AC:H/AT:P/PR:L/UI:P/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Local
Attack Complexity
High
Attack Requirements
Present
Privileges Required
Low
User Interaction
Passive
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

1
Patch available
Oct 29, 2026 - 17:18 EUVD

DescriptionCVE.org

KeePassXC is a cross-platform community-driven port of the Windows application KeePass Password Safe. From 2.3.0 until 2.8.0, KeePassXC browser integration encrypts authorized responses in src/browser/BrowserMessageBuilder.cpp using a fixed 1 MiB output vector even though Botan::Sodium::crypto_box_easy() writes the plaintext length plus crypto_box_MACBYTES. A browser-protocol client that can access the per-user IPC endpoint, has a valid database association, and causes an unlocked database to generate and encrypt a sufficiently large authorized response can trigger a sequential out-of-bounds write before any response is delivered. This issue is fixed in version 2.8.0.

Threat Intelligence Overview

EPSS Score
0.1%
Top 98% exploitable
Prevalence
Medium
popular open-source password manager, common but not universally deployed
Data Quality
3 sources
Confidence: Low

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 No
EPSS 0.1%
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
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

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

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.

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