Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend crafted input with embedded newline to application
-
DeliveryApplication logs attacker data as structured syslog property
-
ExploitUnpatched escapeStructuredDataValue() passes raw newline
-
ExecutionTCP syslog frame terminates mid-stream
-
PersistDownstream collector parses injected bytes as separate RFC 5424 record
-
ImpactForged log entry appears in SIEM with attacker-chosen host and severity
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization CRLF sequence sanitization
|
| Exploitation Conditions | Exploitation requires SyslogSinkOptions.includeStructuredData: true to be explicitly set in the application's syslog sink configuration - this option defaults to false and must be opted into. Additionally, attacker-controlled data must reach a log record's structured properties; this is most likely when an application automatically spreads HTTP request headers, query parameters, or other external metadata into log records using patterns such as Object.assign or spread operators. The TCP syslog transport (RFC 6587 non-transparent framing) must be in use; UDP syslog does not use newline frame delimiters and is not subject to the frame-injection vector (though malformed structured data still results). The SD-NAME key injection path further requires attacker-controlled property key names, a less common but possible pattern when forwarding arbitrary metadata. Limiting factors: the non-default configuration is the primary gate; deployments using the default (includeStructuredData omitted or false) are entirely unaffected. Authentication is not required by the CVSS vector (PR:N), but the attacker must be able to influence data that the application chooses to log as structured properties. |
| Impact | The provided CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:C/C:N/I:H/A:N, 8.6) scores high partly because scope is changed - the integrity of downstream syslog infrastructure is affected, not just the originating process. However, two factors temper real-world risk: (1) the vulnerability only triggers with includeStructuredData: true, an opt-in non-default setting, and (2) exploitation additionally requires attacker-controlled data to reach log properties (e.g., an application spreading request headers directly into log records). These conditions argue for AC:H in an independent assessment rather than AC:L. No EPSS score was provided in source intelligence. No CISA KEV listing was identified at time of analysis, suggesting exploitation has not been observed at scale. A proof-of-concept is publicly available via the GHSA advisory, lowering the bar for exploitation against mis-configured deployments. The 'RCE' tag in the input data is inconsistent with the CVSS impact metrics (C:N/I:H/A:N) and the technical description - this is log injection, not remote code execution; the tag should be treated as a mistagging. The scope-changed integrity impact is real but limited to log record forgery and SIEM correlation disruption rather than host compromise. |
| Exploit ScenarioDerived | An attacker sends an HTTP request to a Node.js web application that spreads request headers into LogTape structured log properties and has SyslogSinkOptions.includeStructuredData: true enabled. A header value such as 'normal\n<134>1 2026-01-01T00:00:00Z forged evil - - - INJECTED' passes through the unpatched escapeStructuredDataValue() with the newline intact; when the syslog sink forwards the message over TCP, the newline terminates the current frame and the forged RFC 5424 header opens a new one. The downstream rsyslog or Splunk collector ingests the injected record as if it originated from host 'forged' at the specified timestamp, corrupting audit trails and potentially suppressing alerts. Proof-of-concept code is publicly available in the GHSA advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 26, 2026
Log injection in @logtape/syslog allows network-accessible attackers to forge arbitrary syslog records in downstream collectors such as rsyslog, Splunk, and Elastic Stack. The escapeStructuredDataValue() function omits C0 control character escaping, so a literal newline embedded in a log property value terminates the current RFC 6587 TCP syslog frame and begins a new one; if the attacker-supplied bytes constitute a valid RFC 5424 header, the downstream collector accepts them as a separate, authentic-looking record. A second injection path exists through unvalidated SD-NAME keys, which can prematurely close structured-data elements. Both paths require the non-default SyslogSinkOptions.includeStructuredData: true setting. Publicly available proof-of-concept code exists; no CISA KEV listing at time of analysis.
RemediationAI
Upgrade @logtape/syslog to the corresponding patched release for your version line: 1.3.11, 2.0.14, or 2.1.5, all available from npm and tagged on GitHub at https://github.com/dahlia/logtape/releases/tag/1.3.11, https://github.com/dahlia/logtape/releases/tag/2.0.14, and https://github.com/dahlia/logtape/releases/tag/2.1.5. The fix (commit 7a6e5b9ddf7915edfff78fa129bc17c979b2a623) replaces C0 control characters with printable #NNN decimal sequences in values and skips SD-NAME keys that fail RFC 5424 grammar validation. If an immediate upgrade is not possible, disable structured data output by setting or removing the includeStructuredData option (it defaults to false), which removes both injection paths entirely at the cost of structured-data enrichment in syslog messages. If your application passes attacker-controlled data (e.g., request headers, user-supplied metadata) into log properties, add an application-level allowlist or sanitization layer for log property keys and values regardless of this patch, as defense in depth against future encoding gaps.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in npm, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The affected package (pkg:npm/@logtape/syslog) is a syslog transport for the LogTape structured logging library, written in TypeScript and targeting Node.js/Deno runtimes. CWE-93 (Improper Neutralization of CRLF Sequences) describes the root cause: output encoding that handles some special characters (backslash, double-quote, closing bracket per RFC 5424) but leaves U+0000-U+001F C0 control characters unescaped. RFC 6587 non-transparent framing uses newline (U+000A) as a stream record delimiter, so a bare newline in a PARAM-VALUE terminates the current syslog PDU in transit. The second defect is an absence of SD-NAME grammar validation (RFC 5424 §7.3.3: printable US-ASCII, max 32 chars, excluding =, ], ", space); keys containing prohibited characters or exceeding the length limit are forwarded verbatim, enabling premature element closure or malformed output. Affected CPE: pkg:npm/@logtape_syslog across the 1.x, 2.0.x, and 2.1.x release lines prior to their respective fixes.
Know when Node.js 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:C/C:N/I:H/A:N
AC:H reflects non-default includeStructuredData:true prerequisite; S:C and I:H retained because downstream syslog collectors suffer integrity loss.
Primary rating from Vendor (https://github.com/dahlia/logtape).
CVSS VectorVendor: https://github.com/dahlia/logtape
DescriptionCVE.org
@logtape/syslog contains two related output-encoding bugs in the structured data formatting code. Both only affect deployments with includeStructuredData: true, which is non-default.
1. Unescaped C0 control characters in structured data values
escapeStructuredDataValue() in packages/syslog/src/syslog.ts escapes \, ", and ] per RFC 5424 but does not escape newline (\n), carriage return (\r), or any other C0 control characters (U+0000-U+001F):
function escapeStructuredDataValue(value: string): string {
return value
.replace(/\\/g, "\\\\")
.replace(/"/g, '\\"')
.replace(/]/g, "\\]");
// \n, \r, and other C0 control characters are not escaped
}TCP syslog commonly uses \n as a frame delimiter (RFC 6587, non-transparent framing). If an attacker-controlled value contains a literal newline, that newline terminates the current syslog frame. Bytes following the newline begin a new frame, and if they form a valid RFC 5424 header (<PRI>1 …), a downstream collector will accept them as a separate, authentic-looking syslog record.
2. Unvalidated SD-NAME keys
Structured data parameter keys are inserted into the message without validation or escaping:
elements.push(`${key}="${escapedValue}"`);RFC 5424 defines SD-NAME as printable US-ASCII characters excluding =, ], ", and space, with a maximum length of 32. A key containing any of those characters, control characters, or exceeding the length limit will produce malformed structured data. If the key itself contains an embedded ], it can prematurely close the structured-data element.
In typical usage, property keys are developer-defined string literals and therefore safe. However, if an application forwards attacker-controlled keys as log properties-for example by spreading request headers or arbitrary metadata into a log record-this becomes a second injection path.
Proof of concept
The following Node.js snippet (no dependencies, no network required) demonstrates that the escaped value still contains a literal newline:
function escapeStructuredDataValue(value) {
return value
.replace(/\\/g, "\\\\")
.replace(/"/g, '\\"')
.replace(/]/g, "\\]");
}
const payload =
'normal\n<134>1 2026-01-01T00:00:00Z forged evil - - - INJECTED';
const result = escapeStructuredDataValue(payload);
console.log("Newline present after escape:", result.includes("\n")); // trueTested with Node.js 22.17.1.
Impact
An attacker who controls log property values can:
- forge syslog records attributed to arbitrary hosts, applications, or process IDs;
- insert records with arbitrary severity or facility levels;
- obscure malicious activity by injecting misleading entries around legitimate ones;
- break downstream log parsers or SIEM correlation rules that rely on log integrity.
Affected downstream collectors include rsyslog, syslog-ng, Splunk, Elastic Stack, and any other system using RFC 6587 non-transparent framing.
Suggested fix
Structured data values
Escape all C0 control characters (U+0000-U+001F) in addition to \, ", and ]. RFC 5424 does not define an escape sequence for control characters in PARAM-VALUE; the most interoperable approach is to strip or replace them:
function escapeStructuredDataValue(value: string): string {
return value
.replace(/\\/g, "\\\\")
.replace(/"/g, '\\"')
.replace(/]/g, "\\]")
.replace(/[\x00-\x1f]/g, (c) =>
`\\x${c.charCodeAt(0).toString(16).padStart(2, "0")}`
);
}Alternatively, strip them entirely: .replace(/[\x00-\x1f]/g, ""). The right choice depends on whether downstream consumers need some representation of the original value.
SD-NAME keys
Validate each key against the RFC 5424 SD-NAME grammar before including it. Keys that fail validation should be skipped or sanitized:
// SD-NAME: printable US-ASCII, excluding '=', ']', '"', SP; max 32 chars
const SD_NAME_RE = /^[!-<>-Z\\^-z|~]{1,32}$/;
for (const [key, value] of Object.entries(record.properties)) {
if (!SD_NAME_RE.test(key)) continue;
const escapedValue = escapeStructuredDataValue(String(value));
elements.push(`${key}="${escapedValue}"`);
}Executive ViewAI
@logtape/syslog vulnerability allows attackers to forge legitimate-appearing syslog records in downstream systems like rsyslog, Splunk, and Elastic Stack, directly compromising the audit trail integrity that organizations depend on for compliance validation and security incident investigation. Publicly available exploit code exists, increasing risk exposure. Structured-data-enabled configurations are immediately at risk.
Apply vendor patch.
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
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Remote code execution in n8n's workflow expression evaluation system allows an authenticated user with workflow creation
A vulnerability in the NuPoint Unified Messaging (NPM) component of Mitel MiCollab through 9.8 SP1 FP2 (9.8.1.201) could
FortiOS and FortiProxy contain an authentication bypass via the Node.js websocket module allowing unauthenticated remote
Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour
Eval injection vulnerability in the internals.batch function in lib/batch.js in the bassmaster plugin before 1.5.2 for t
Flowise version 3.0.5 contains a remote code execution vulnerability in the CustomMCP node. The mcpServerConfig paramete
Node.js 8.5.0 before 8.6.0 allows remote attackers to access unintended files, because a change to ".." handling was inc
An issue was discovered in the node-serialize package 0.0.4 for Node.js. Rated critical severity (CVSS 9.8), this vulner
OpenSSL before 0.9.8za, 1.0.0 before 1.0.0m, and 1.0.1 before 1.0.1h does not properly restrict processing of ChangeCiph
Directory traversal vulnerability in the st module before 0.2.5 for Node.js allows remote attackers to read arbitrary fi
Multiple SQL injection vulnerabilities in the Manage Accounts page in the AccountManagement.asmx service in the Solarwin
The JS-YAML module before 2.0.5 for Node.js parses input without properly considering the unsafe !!js/function tag, whic
EUVD-2026-66563
GHSA-8h6h-x5pq-56fq
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB