Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach per-user browser IPC endpoint
-
DeliveryEstablish valid database association (test-associate)
-
ExploitRequest oversized authorized response from unlocked DB
-
ExecutionTrigger out-of-bounds write in crypto_box_easy
-
ImpactCrash 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
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
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.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.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
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.
What every action level means
SSVC AssessmentENISA
Priority Score
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.
Issue in KeePassXC 2.7.7 allows an attacker (who has the privileges of the victim) to recover some passwords stored in t
KeePassXC 2.7.7 allows an attacker (who has the privileges of the victim) to recover cleartext credentials via a memory
Local privilege escalation in KeePassXC password manager allows authenticated attackers with low privileges to execute a
In KeePassXC through 2.7.5, a local attacker can make changes to the Database security settings, including master passwo
A heap use-after-free in KeePassXC's legacy KeePass1/KDB import path can crash the application and permit a limited, att
EUVD-2026-113213
NVD
CVE.org
EPSS
GitHub
Exploit-DB