Wazuh
CVE-2025-62787
LOW
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCompromise or enroll Wazuh agent
-
ExploitCraft malicious winevt message
-
ExecutionTrigger over-read in DecodeWinevt
-
ImpactLeak adjacent memory via mdebug2 log
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Buffer over-read prevention
|
| Exploitation Conditions | Two concrete prerequisites must both hold for data to leak: (1) the attacker must control an agent that can send messages to the manager - i.e. an already-compromised or maliciously enrolled Wazuh agent (reflected as PR:H), and (2) the Wazuh manager must be running with the non-default debug setting analysisd.debug=2, because the over-read data is only exposed while resolving the arguments of the mdebug2() debug log call. The over-read itself always triggers in DecodeWinevt() when the crafted winevt message is parsed, but without analysisd.debug=2 the leaked bytes are never emitted. Limiting factors: requires privileged/trusted agent position, requires a non-default verbose debug configuration, and affects only the Windows Event Channel decoder path; default production deployments do not expose the leaked data. |
| Impact | This is a genuinely low-priority issue, and the signals are internally consistent rather than conflicting. The vendor-assigned CVSS 4.0 score is only 2.1, driven by PR:H (attacker must already control an enrolled/compromised Wazuh agent), AT:P (a specific attack requirement - the analysisd.debug=2 configuration must be set for data to actually leak), and limited impact (VC:L/VI:N/VA:L): a bounded over-read of confidentiality with no integrity impact and only marginal availability effect. POC/exploit material exists (the GitHub Security Advisory GHSA-3hhq-5367-98q6 and the fixing commit), so publicly available exploit code exists, but there is NO CISA KEV listing and no EPSS value was supplied in the input, so exploitation probability cannot be quantified from this data. Crucially, the real-world confidentiality impact is gated behind a non-default debug setting - on default deployments the over-read is triggered but the leaked data is never emitted. The combination of required privileged access (a compromised agent), a required non-default configuration, and low technical impact means this is a high-confidence LOW, not a high-CVSS/low-real-risk mismatch. No key signals conflict; the main gap is the absence of EPSS/KEV data to judge exploitation activity. |
| Exploit ScenarioDerived | An attacker who has already compromised a Wazuh agent (or can enroll a malicious one) crafts a specially formed Windows Event Channel message and sends it to the Wazuh manager, triggering a buffer over-read in DecodeWinevt() due to an incorrect array index. If the manager is running with analysisd.debug=2, the over-read memory - which may contain adjacent sensitive data - is written into debug log output via the mdebug2 call. Public exploit/advisory material exists (GHSA-3hhq-5367-98q6 and the fixing commit). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Wazuh managers before 4.10.2 contain an out-of-bounds read in the Windows Event Channel decoder (DecodeWinevt) that is reachable by a compromised or maliciously enrolled agent sending a crafted winevt message. The over-read is triggered while parsing the message, but the leaked memory is only exposed when the manager runs with the non-default analysisd.debug=2 setting because the faulty access is evaluated in an mdebug2 diagnostic call; publicly available exploit code exists, with no CISA KEV confirmation of active exploitation. Consistent with the assessed CVSS 3.1 vector (AV:N/AC:H/PR:H/UI:N/S:U/C:L/I:N/A:L), impact is limited: a privileged/trusted agent position is required, attack complexity is high, and only limited confidentiality and availability effects are expected.
RemediationAI
Vendor-released patch: upgrade Wazuh to 4.10.2 or later, applying the fix commit 267d5d55de490469a9ec24a2b936bb3c5aa8fdda and the guidance in GHSA-3hhq-5367-98q6 (https://github.com/wazuh/wazuh/security/advisories/GHSA-3hhq-5367-98q6). If immediate upgrade is not possible, remove the data-leak condition by ensuring analysisd.debug is not set to 2 and keeping production debug logging disabled; this prevents the over-read bytes from being emitted, but the underlying out-of-bounds read and limited availability effect can still occur. Additionally, restrict agent enrollment and agent-channel reachability to trusted hosts and keys, since exploitation requires a compromised or maliciously enrolled agent and a privileged/trusted position (PR:H in the assessed vector); this reduces exposure but may complicate legitimate agent onboarding and requires careful key management. Monitor manager logs and agent enrollment activity for unexpected winevt payloads or anomalous debug output. Note that disabling debug logging reduces diagnostic visibility, and restricting agent access may affect distributed deployments that rely on many agents.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The issue is a CWE-126 buffer over-read in src/analysisd/decoders/winevtchannel.c, part of Wazuh's analysisd component that decodes Windows Event Channel messages received from agents. In the vulnerable code, an incorrect index (j instead of l) is used when reading child_attr[p]->attributes[j], so a crafted winevt payload can cause a read past the end of the allocated buffer while resolving arguments to the mdebug2() debug log call. The over-read occurs during decoding, but sensitive bytes are only emitted to logs when analysisd.debug=2 is configured; with default debug settings, the data is not exposed. The vendor fix in 4.10.2 corrects the index, resets program_name and dec_timestamp to force a clean event, and clears XML state with OS_ClearXML(&xml). The affected product is identified by CPE cpe:2.3:a:wazuh:wazuh:*:*:*:*:*:*:*:* prior to the 4.10.2 boundary, and the vulnerable path specifically involves the manager parsing agent-supplied Windows Event Channel data.
Know when Wazuh 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:N/AC:L/AT:P/PR:H/UI:N/VC:L/VI:N/VA:L/SC:N/SI:N/SA:N
AV:N as a compromised agent sends messages over the network, PR:H for the trusted-agent requirement, AC:H because the analysisd.debug=2 non-default config is needed to leak data, C:L/A:L for bounded over-read.
Primary rating from Vendor (github).
CVSS VectorVendor: github
DescriptionCVE.org
Wazuh is a free and open source platform used for threat prevention, detection, and response. Prior to 4.10.2, a buffer over-read occurs in DecodeWinevt() when child_attr[p]->attributes[j] is accessed, because the corresponding index (j) is incorrect. A compromised agent can cause a READ operation beyond the end of the allocated buffer (which may contain sensitive information) by sending a specially crafted message to the wazuh manager. An attacker who is able to craft and send an agent message to the wazuh manager can cause a buffer over-read and potentially access sensitive data. While the buffer over-read is always triggered while resolving the arguments of mdebug2, specific configuration options (analysisd.debug=2) need to be in place for the respective data to be leaked. This vulnerability is fixed in 4.10.2.
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Affected Products (CPE)CVE.org
Wazuh SIEM platform versions 4.4.0 through 4.9.0 contain an unsafe deserialization vulnerability in the DistributedAPI t
In the wazuh-slack active response script in Wazuh 4.2.x before 4.2.5, untrusted user agents are passed to a curl comman
Path-traversal-driven root code execution affects the Wazuh security platform's cluster synchronization layer in version
Arbitrary file read in Wazuh cluster deployments (4.0.0 through 4.14.5, and 5.0.0-beta1/beta2) lets a peer node that alr
Arbitrary file write leading to root remote code execution affects Wazuh worker nodes in clustered deployments running v
A critical deserialization vulnerability in Wazuh's cluster mode allows attackers with access to any worker node to achi
Wazuh Agent before 4.13.0 on Windows can be made by an authenticated, high-privileged configuration writer to open attac
Remote code execution on the Wazuh cluster master node is achievable by any attacker who controls a cluster worker node,
Path traversal in Wazuh's ip-customblock active response script allows low-privileged remote attackers to create or dele
The agent in OSSEC through 3.1.0 on Windows allows local users to gain NT AUTHORITY\SYSTEM access via Directory Traversa
Cluster key disclosure in Wazuh Manager versions 4.0.0 through 4.14.4 enables a two-stage privilege escalation: a low-pr
Unauthenticated remote denial of service in the Wazuh cluster daemon (wazuh-clusterd) allows a network peer to exhaust p
NVD
CVE.org
EPSS
GitHub
Exploit-DB