Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessInfluence data that gets logged
-
ExploitInflate logged message past event-log budget
-
ImpactEntire audit record silently dropped
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A09:2025 - Security Logging & Alerting Failures
ASVS 5.0
V16 - Security Logging and Error Handling Sufficient logging implementation
|
| Exploitation Conditions | Requires a specific deployment: an application running on Windows that uses log4net's EventLogAppender (versions 1.2.9 up to but not including 3.5.0) and that writes attacker-influenceable content into event-log messages. The attacker must be able to make a single logged message large enough that 'message + logName + applicationName + machineName' exceeds the true Windows Event Log record ceiling (~31,736 characters measured on Windows 11 build 26200), at which point the service stores and reports nothing. Limiting factors: non-default/less-common appender choice (EventLogAppender specifically), Windows-only, a long default applicationName (app-domain/assembly name) reduces the attacker's required payload while a short one increases it, and the attacker needs enough control over logged content to reach tens of kilobytes in one record. |
| Impact | Signals point to a genuine but low-priority, niche-configuration issue rather than an urgent one. The CVSS 3.1 base score is 5.3 (Medium) with AV:N/AC:L/PR:N/UI:N, which superficially reads as 'easy remote unauthenticated' - but the impact metrics are C:N/I:L/A:N, meaning the only consequence is partial loss of log integrity (silent suppression of Windows Event Log records), not code execution, data disclosure, or denial of service. No EPSS score was provided in the input, so exploitation probability cannot be quantified here. There is no CISA KEV listing and no public proof-of-concept referenced, and no SSVC decision data was supplied; by the precision rules this is 'no public exploit identified at time of analysis.' Note a conflict in the metadata: the input carries an 'Information Disclosure' tag, yet CWE-778 (Insufficient Logging) and the C:N vector make this an integrity/anti-forensics problem (an attacker suppresses audit records), not a confidentiality one - treat the tag as inaccurate. The AV:N/PR:N framing is defensible because the 'attacker' only needs their data to reach a logged message, but the practical precondition (pushing a single rendered message plus the log/source/machine names past the ~31,736-character Windows ceiling on an app specifically using EventLogAppender) sharply narrows real-world exploitability. Net: a legitimate detection-evasion/logging-reliability defect worth patching on affected Windows deployments, but not a drop-everything emergency. |
| Exploit ScenarioDerived | A Windows application using log4net's EventLogAppender logs attacker-influenced data (e.g., a username, HTTP header, or request field). The attacker submits input long enough that the rendered message combined with the log name, source/application name, and machine name exceeds the real Windows Event Log budget, causing the Event Log service to silently discard the entire record - suppressing evidence of the attacker's own activity. No public exploit is identified at time of analysis; exploitation is low-complexity (AC:L) and requires no authentication per the vector. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 06, 2026
Silent suppression of Windows event-log records in Apache log4net's EventLogAppender lets a party that can influence logged content erase a whole event record without any error being raised. Applications on Windows that use EventLogAppender in log4net 1.2.9 through versions before 3.5.0 are affected: messages are truncated to a hard-coded 31,837-character ceiling that exceeds the real Event Log record budget once the log name, source name, and machine name are counted, so the service silently stores and reports nothing for the oversized record. No public exploit identified at time of analysis, and the independent assessment rates this a genuine but low-priority, niche-configuration issue (CVSS 3.1 base 5.3, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N), since an attacker must be able to push a single logged message into the tens-of-kilobytes range.
RemediationAI
Upgrade to Apache log4net 3.5.0, the vendor-released patch version, which computes the message budget from the log name, source and machine name, clamps it at zero, and reports truncation through the ErrorHandler; the fix is carried in commit 28fbfb25678c48a8cc5bc9b94ead0dddfc39ffed / PR https://github.com/apache/logging-log4net/pull/315 and announced at https://lists.apache.org/thread.html/jr6fj5skv1vnjbc9jmt8bp151p8ow1rp. If upgrading is not immediately possible, reduce the effective message size before it reaches the appender: cap rendered output with a layout or conversion-pattern maximumLength (trade-off: legitimate log content is truncated, though the record is at least retained), or lower the appender's maxEventlogMessageSize and keep the combined message + LogName + ApplicationName + MachineName below roughly 31,736 characters (trade-off: the safe value depends on how long the consuming assembly's app-domain name is, so a short ApplicationName leaves more room and a long one less). Setting a short, explicit ApplicationName instead of relying on the default app-domain name also raises the usable budget. As a lower-fidelity compensating control, route security-relevant events to a non-EventLog appender such as a file or remote appender (trade-off: loses native Windows Event Log integration, forwarding and SIEM collection), and in 3.5.0 attach an ErrorHandler to the appender so truncation is at least observable - noting that the underlying Event Log service gives no notification of dropped records at all.
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
The root cause is class CWE-778 (Insufficient Logging) realized as a wrong size assumption in the EventLogAppender, which writes to the Windows Event Log through the ReportEvent API and its lpStrings buffer. The appender previously used the constant 31839 - 2 = 31837 characters as a truncation limit, but the Event Log treats the record size as a shared budget: the log name, the event source (ApplicationName, which defaults to the app domain/assembly name) and the machine name are all spent from the same ceiling. Measurement on Windows 11 build 26200 showed a record is stored only while message + logName + applicationName stays within 31,736 characters, and one character beyond that causes the service to store nothing and report nothing, while still consuming the log's space and in some cases leaving the log unreadable. The upstream fix replaces the constant with a computed GetMaxMessageSize() budget that subtracts LogName.Length, ApplicationName.Length, machineName.Length and a 1024-character safety margin, clamps at zero, and raises an ErrorHandler signal when truncation occurs - the only signal available because the Event Log itself reports neither truncated nor dropped records.
Know when Log4Net 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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N
Attacker-influenced data reaching a logged message remotely with no privileges silently suppresses the audit record, so AV:N/PR:N and an integrity-only I:L; no confidentiality or availability impact.
Primary rating from Vendor (apache).
CVSS VectorVendor: apache
Lifecycle Timeline
2DescriptionCVE.org
Insufficient Logging vulnerability in the EventLogAppender of Apache log4net.
Long messages were truncated to a fixed size that exceeds what the Windows Event Log accepts once the log and source names are counted, and the event log then stored nothing and reported nothing. A party whose data reaches a log message could suppress the whole record by making it long enough. Only applications on Windows that use EventLogAppender are affected.
This issue affects Apache log4net: from 1.2.9 before 3.5.0.
Users are recommended to upgrade to version 3.5.0, which fixes the issue.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Log-integrity tampering in the RemoteSyslogAppender of Apache log4net affects versions from 1.2.12 up to but not includi
Log-record suppression in the %aspnet-request pattern converter of Apache log4net lets an unauthenticated remote sender
Improper handling of Unicode encoding in Apache log4net's SmtpPickupDirAppender lets an attacker who can place unencodab
Log-record truncation in Apache log4net's EventLogAppender silently drops everything a layout renders after a NUL (\0) c
A NUL character (U+0000) embedded in content that reaches a log message causes Apache log4net's OutputDebugStringAppende
EUVD-2026-93869
GHSA-j8mm-w573-8v6c
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB