SecurityNot yet confirmed elsewhere1 publisher2 min readPublished
On Windows, a named pipe is a local API: assume everything on the box can knock
A ThreatLocker explainer restates a boundary developers keep skipping: a pipe connection proves only that the caller could open the pipe. The rest is ACLs, per-command authorization, and code.
The Watch · Security desk
What happened
- A ThreatLocker author writing on BleepingComputer argues a named pipe should be treated as an exposed local interface, with the server establishing who connected before it acts.
- A single Windows workstation mixes LocalSystem, administrator, standard user and service-account processes across sessions, plus third-party tools and anything running under a compromised account.
- Connecting successfully proves only that the client could open the pipe, not that it is the intended program or that its user is permitted to ask for anything.
- The recommendation is to set pipe permissions explicitly and narrowly, since grants to Everyone, Authenticated Users or all interactive users let unrelated processes reach the pipe.
Why it matters
- exposure Once a LocalSystem service will modify protected files, touch the registry or start processes on request, a compromised standard-user account is one successful connect away from all of it.
- constraint The platform will not tell a server which executable was meant to use the pipe, so identity checking has to be written into each privileged server; no permissions dialog substitutes for it.
- cost The work sits inside the service binary, so it is paid for by whoever ships the agent; a customer holding a compiled service cannot add caller verification to someone else's code.
The failure mode worth naming is the confused deputy: the attacker supplies the instruction and the privileged service supplies the privileges [14]. It arrives whenever a request read off a pipe is turned directly into a file, registry, process or command-line operation [14]. The remedies on offer are unglamorous: strict message framing with bounded sizes [15], and authorization applied per command, so that an identity cleared to query service status is not thereby cleared to stop the service or launch a process [9]. Worth noting who the hostile payloads are attributed to. The source lists five classes of bad input, including oversized payloads and corrupted serialized objects, and attributes all of them to a client that has already authenticated [13][18].
Server-side permissions do nothing for the process on the other end. A pipe name is an identifier and not a secret, and it does not prove which process created the pipe [11]. An attacker who claims the name before the legitimate server starts collects the client's connection instead [11], which makes service start order a security property rather than an operational detail. The first-pipe-instance option detects that the name was already taken, and that is all it does; it is neither access control nor server identity verification [12].
Impersonation is the sanctioned way for a privileged server to act in the caller's context, and the conditions attached to it are the interesting part: verify that impersonation actually succeeded, keep the impersonated stretch short, and restore the original identity afterwards [10]. The verification step exists because the server cannot assume the switch happened. A server that skips the check has no basis for believing the work it does next belongs to the caller rather than to itself.
Provenance shapes how much this can carry. The piece is written by Farid Mustafayev, described as a cybersecurity expert at ThreatLocker, published on BleepingComputer, and it links back to the vendor's own material on excessive permissions and zero trust [16]. It cites no CVE and names no affected product, and it offers no measurement of how often shipping software gets a pipe ACL wrong [17]. The mechanism does not need a victim to be real, but without prevalence there is nothing here to argue with except your own code. The population implied is not narrow: the source's list of typical pipe users runs through Windows services, desktop applications, tray processes, command-line utilities and background agents [1], and the arrangement it singles out is a privileged service talking to a user-facing application that developers treat as internal [2].
What to watch
- A CVE against a shipping privileged Windows agent that names a permissive pipe ACL as the defect, which would move this from design advice into patch management.
- Any measurement of how many third-party Windows services grant pipe access to Authenticated Users or all interactive users, which this article does not supply.
- The same guidance appearing in Microsoft platform documentation rather than under a security vendor's byline.
Clarity's read
What the record supports and how the coverage leans. The claims behind it follow.
Reality
- Evidence44
- Adoption
- Insufficient
- Hype gap+22
- Incentives74
- Confidence41
Claim ledger
Ranked by verification strength, evidence, and original report placement.
- [1]
Named pipes are a common choice for communication between applications on the same Windows computer, are fast and supported directly by the operating system, and work well between Windows services, desktop applications, tray processes, command-line utilities and background agents.
- [2]
A typical design includes a privileged Windows service acting as the named-pipe server with a user-facing application connecting as the client; because both run on the same computer, developers often treat the communication as internal and therefore trusted.
- [3]
A Windows workstation may run processes under LocalSystem, administrators, standard users, service accounts and separate interactive or remote sessions, and may also contain third-party software, scripts, diagnostic tools and malware operating under a compromised account.
- [4]
Any process that knows the pipe name and has sufficient access rights can attempt to connect, and Windows does not inherently know which executable the developer intended to use the pipe.
- [5]
A named pipe should be treated as an exposed local interface; before processing a request the application must determine who connected, what that identity is allowed to do, and whether the supplied data is safe.
- [6]
A service running as LocalSystem may modify protected files and registry keys, launch processes, change system configuration, access other users' data or communicate with kernel drivers; when those operations are exposed through a named pipe, the pipe becomes an API to privileged functionality.
- [7]
A successful connection proves only that the client was allowed to open the pipe; it does not prove the client is the expected application, that the connected user is authorized, that the requested operation is permitted, or that the supplied command is safe.
- [8]
Pipe permissions should be defined explicitly and restricted to the smallest appropriate set of identities; broad permissions for Everyone, Authenticated Users or all interactive users may allow unrelated processes to reach the pipe.
- [9]
Authentication and authorization must remain separate: a user may be allowed to query service status but not stop the service, change protected settings, launch processes or access arbitrary files, and sensitive commands should be authorized individually.
- [10]
Impersonation can help by performing operations under the client's security context, but the server should verify that impersonation succeeded, limit the work performed while impersonating, and always restore its original identity.
- [11]
The client must verify the server: a predictable pipe name is only an identifier, is not a secret, and does not prove which process created the pipe; an attacker may create a pipe using the expected name before the legitimate server starts, causing the client to connect to an attacker-controlled process.
- [12]
The first-pipe-instance option can help detect that the pipe name has already been claimed, but it does not replace proper access controls or server identity verification.
- [13]
Messages received through the pipe must be treated as untrusted input, because even an authenticated client may send malformed or oversized payloads, invalid file or registry paths, unsupported command combinations, corrupted serialized objects, or values designed to trigger error conditions.
- [14]
A privileged service that converts pipe input directly into file, registry, process or command-line operations may become a confused deputy: the attacker supplies the instruction while the service supplies the privileges.
- [16]
The article was written by Farid Mustafayev, described as a cybersecurity expert at ThreatLocker, published by bleepingcomputer.com, and includes promotional links to ThreatLocker material on excessive permissions in AI tools and on a zero trust strategy.
- [17]
The article cites no CVE identifier, names no specific affected product, and gives no measurement of how commonly shipping Windows software misconfigures named-pipe permissions.
- [18]
The source enumerates five distinct classes of hostile or malformed payload that may arrive from an already-authenticated pipe client.
Sources
1 independent publisher whose own reporting we read for this story.
- bleepingcomputer.comNamed Pipes Under Attack: Securing Windows Interprocess Communication
1 article · August 22, 2026
Topics and entities
Follow any of these and your For You feed starts watching them — no settings page required.
Topics
- Local Privilege EscalationFollow
- Windows Named Pipe SecurityFollow
- Secure IPC DesignFollow
- Vendor-Authored Security ContentFollow
Entities
- Windows Named PipesFollow
- Microsoft WindowsFollow
- ThreatLockerFollow
- Farid MustafayevFollow
- BleepingComputerFollow
- LocalSystemFollow