Skip to main content

@logtape/syslog CVE-2026-54511

| EUVDEUVD-2026-66563 HIGH
Improper Neutralization of CRLF Sequences ('CRLF Injection') (CWE-93)
2026-08-26 https://github.com/dahlia/logtape GHSA-8h6h-x5pq-56fq
8.6
CVSS 3.1 · Vendor: https://github.com/dahlia/logtape
View

Attack ChainAIDerived

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

  1. Access
    Send crafted input with embedded newline to application
  2. Delivery
    Application logs attacker data as structured syslog property
  3. Exploit
    Unpatched escapeStructuredDataValue() passes raw newline
  4. Execution
    TCP syslog frame terminates mid-stream
  5. Persist
    Downstream collector parses injected bytes as separate RFC 5424 record
  6. Impact
    Forged 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

logtape < 1.3.11
logtape 2.1.0, < 2.1.5
logtape 2.0.0, < 2.0.14

Affected Packages

npm @logtape/syslog fix: 1.3.11, 2.0.14, 2.1.5
euvd logtape fix: 1.3.11, 2.0.14, 2.1.5

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

Vendor (https://github.com/dahlia/logtape) PRIMARY 8.6 HIGH
AV:N/AC:L/PR:N/UI:N/S:C/C:N/I:H/A:N
vuln.today AI 6.8 MEDIUM

AC:H reflects non-default includeStructuredData:true prerequisite; S:C and I:H retained because downstream syslog collectors suffer integrity loss.

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

Primary rating from Vendor (https://github.com/dahlia/logtape).

CVSS VectorVendor: https://github.com/dahlia/logtape

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Changed
Confidentiality
None
Integrity
High
Availability
None

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):

typescript
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:

typescript
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:

javascript
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")); // true

Tested 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:

typescript
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:

typescript
// 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

Why It Matters

@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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 77% exploitable
Prevalence
Low
niche npm syslog transport for a minor logging library
Threat Intel
1
1 sources
Exploit
POC
Public exploit code exists
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA GitHub

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 HIGH
CISA KEV No
Public POC Yes
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

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

Attack Technique

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

CVE-2025-68613 HIGH POC
8.8 Dec 19

Remote code execution in n8n's workflow expression evaluation system allows an authenticated user with workflow creation

CVE-2024-41713 CRITICAL POC
9.1 Oct 21

A vulnerability in the NuPoint Unified Messaging (NPM) component of Mitel MiCollab through 9.8 SP1 FP2 (9.8.1.201) could

CVE-2024-55591 CRITICAL POC
9.8 Jan 14

FortiOS and FortiProxy contain an authentication bypass via the Node.js websocket module allowing unauthenticated remote

CVE-2023-44487 HIGH POC
7.5 Oct 10

Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour

CVE-2014-7205 CRITICAL POC
10.0 Oct 08

Eval injection vulnerability in the internals.batch function in lib/batch.js in the bassmaster plugin before 1.5.2 for t

CVE-2025-59528 CRITICAL POC
10.0 Sep 22

Flowise version 3.0.5 contains a remote code execution vulnerability in the CustomMCP node. The mcpServerConfig paramete

CVE-2017-14849 HIGH POC
7.5 Sep 28

Node.js 8.5.0 before 8.6.0 allows remote attackers to access unintended files, because a change to ".." handling was inc

CVE-2017-5941 CRITICAL POC
9.8 Feb 09

An issue was discovered in the node-serialize package 0.0.4 for Node.js. Rated critical severity (CVSS 9.8), this vulner

CVE-2014-0224 HIGH POC
7.4 Jun 05

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

CVE-2014-3744 HIGH POC
7.5 Oct 23

Directory traversal vulnerability in the st module before 0.2.5 for Node.js allows remote attackers to read arbitrary fi

CVE-2014-9566 HIGH POC
7.5 Mar 10

Multiple SQL injection vulnerabilities in the Manage Accounts page in the AccountManagement.asmx service in the Solarwin

CVE-2013-4660 MEDIUM POC
6.8 Jun 28

The JS-YAML module before 2.0.5 for Node.js parses input without properly considering the unsafe !!js/function tag, whic

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