A local MCP server has no authentication boundary of its own.
Every local MCP server your developers install is a privileged process running as them, and neither transport the protocol offers gives it an identity to check: stdio has no authentication by construction, and a loopback HTTP server is reachable by any process on the box — and, via DNS rebinding, by any web page they visit, unless the server validates the Origin header. The major SDKs shipped that check off by default. So the control that works is a fleet inventory and an install allowlist, because nothing inside the server is going to ask who is calling.
Step 1The two transports fail in opposite directions.
MCP gives a local server two ways to be reached, and the security properties are not comparable — which matters because the choice is usually made by whoever packaged the server, not by you.
- stdio. The client launches the server as a child process and talks over pipes. There is no listener, so nothing on the network can reach it. In exchange there is no authentication and none is possible: the server trusts its parent absolutely, inherits the user's environment, their filesystem rights and whatever tokens sit in their home directory. Its security boundary is the OS user account, and nothing narrower.
- Loopback HTTP. The server binds a port on the machine and accepts requests. Now it has a listener, and the listener cannot tell callers apart: every other process on that host can call it, and the protocol's own guidance is that a local server SHOULD bind only to
127.0.0.1rather than0.0.0.0, SHOULD authenticate connections, and MUST validate theOriginheader on all incoming connections to prevent DNS rebinding attacks.
Read that last requirement twice, because it is the one that gets skipped. Binding to loopback keeps the port off the LAN; it does nothing about a request that originates on the machine. The MCP transport model and its trust assumptions are laid out in the streamable HTTP deep-dive; what is operationally new is that the population of these servers is now on laptops rather than in your cluster.
Step 2DNS rebinding turns a localhost server into a remote one.
This is the attack most teams do not model, so it is worth stating mechanically. The user visits a page. The page's domain resolves, briefly, to a host the attacker controls, and then re-resolves to 127.0.0.1. The browser's same-origin policy compares domain names, not the IP addresses they currently resolve to — so as far as the browser is concerned, script on that page is still talking to its own origin, and it happily issues requests to your local MCP server. The request arrives on loopback, from the user's own browser, with the user's own machine as its source.
Which is why the Origin check is a MUST and loopback binding is only a SHOULD. The server is the only party in that exchange that can tell the difference, and it can only do so by looking at the header the browser is obliged to send and reject what it does not recognise — the specification's remedy is an HTTP 403 for a present-but-invalid Origin.
# what each control actually stops bind 127.0.0.1 → another host on the LAN blocked bind 127.0.0.1 → another process on this laptop not blocked bind 127.0.0.1 → a web page via DNS rebinding not blocked validate Origin → a web page via DNS rebinding blocked validate Origin → another process on this laptop not blocked # nothing in the transport stops a local process. that is the design.
Public reporting through 2026 says the TypeScript, Python and Go SDKs all shipped their localhost HTTP transport with rebinding protection off unless the author opted in, with CVEs assigned and a fix in the TypeScript SDK from 1.24.0. We could not trace those identifiers to the advisories themselves, so treat the version numbers as a prompt to check your own dependency rather than as a citation. The durable part needs no CVE: a default-off security control in a library used by thousands of single-author servers means most deployed servers do not have it.
Step 3The dangerous servers are the ones with no network at all.
Having said all that about HTTP, the higher-impact exposure is usually the stdio server, precisely because it looks inert. It has no port to scan, shows up in no network inventory, and is therefore absent from the asset list your security team maintains — while holding tool access to the filesystem, the shell, a cloud credential helper or a production database, under the identity of a human with broad rights.
Two consequences follow for how you run them:
- The server is a software supply-chain item, not a configuration line. It is usually an
npxoruvxinvocation that resolves a package at launch, which means the code executing inside your user's session can change without any change to the config you reviewed. Pin it. Pinning and verification is the general form, and vetting a third-party skill is the review checklist that transfers almost unchanged. - Its tool descriptions are inputs to your model. A server you install gets to write text that lands in the agent's context on every turn, which is the tool-poisoning path in MCP tool poisoning. An update can change those descriptions without changing the tool's name or signature.
Together those mean the install decision is the whole security decision, and it is currently being made one developer at a time. The related endpoint-side problem — the credentials and transcripts these clients leave in predictable paths — is agent artifacts on the endpoint.
Step 4Desktop applications are becoming MCP servers, and the subject is the open document.
The population is about to change shape. At MAX on 10 November 2026 Adobe previewed local MCP integrations for Photoshop, Illustrator, Premiere and After Effects, letting an outside agent act on native project files on the user's own machine; Adobe put availability at private beta in early 2027, so there is nothing to install today. Treat it as the direction rather than a deployment: a GUI application that holds unsaved state becomes an MCP server, and the thing the agent acts on is whatever document happens to be open.
That breaks two assumptions in most agent threat models. The target is not a path you can allowlist — it is a selection, a timeline, a layer stack held in a running process, so a scope rule written in terms of directories does not express it. And the authority is ambient: the agent gets whatever the application can currently do, including to files the user opened from a network share minutes ago and has not saved. Inventory these the day they arrive, and ask the blast-radius question in terms of documents rather than directories.
Step 5Four controls, in the order they pay off.
None of these requires the servers to cooperate, which is the point — you cannot patch a thousand single-author servers, but you can decide which ones run.
- Inventory. Enumerate the client config files on managed endpoints and report which servers are configured, at which version or package spec, per host. This is a file-collection job your existing endpoint tooling already does; it is the one control nothing else works without, and it is the same registry discipline as agent inventory and registry, applied one layer down.
- Allowlist, with pinned versions. Decide centrally which servers may be installed and at what version, and distribute the config rather than letting each developer assemble it. An unpinned entry is an unpinned vendor default with shell access.
- A transport rule. Prefer stdio for anything that does not need to be shared between clients, because a server with no listener cannot be reached by a web page at all. Where loopback HTTP is required, require evidence that the server validates
Originand binds127.0.0.1— this is testable in onecurlwith a forged header, so make it an acceptance check rather than a policy sentence. - Egress, not just install. A local server with network access is the exfiltration path for everything it can read, which is why egress control belongs on the endpoint and not only in the sandbox. The credential question — what the server can reach with the tokens lying next to it — is scoped credentials for agents.
acceptance check for a loopback MCP server
$ curl -s -o /dev/null -w '%{http_code}\n' \
-H 'Origin: https://evil.example' \
-H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' \
http://127.0.0.1:PORT/mcp
403 -> Origin validation present. ship it.
200 -> any web page the user visits can call this server.
Step 6What you can and cannot learn after the fact.
Assume one of these servers is used against a user and ask what you would have. The MCP client holds a local record of the session; the server may log nothing; the tool calls never traversed your network, so there is no proxy log; and the actions appear in downstream systems as the user, because they were the user. That is the same attribution problem as third-party agents logging in as your users, with the added difficulty that the acting process was on a laptop you do not control.
So the forensics has to be arranged in advance, and cheaply. Collect the client's own session records as endpoint telemetry on the same schedule as everything else, keeping in mind that a transcript is untrusted content and a privacy liability — PII redaction in agent traces applies before it lands in a SIEM. Where a server touches something that matters, put the audit on the far side: the database's own log, the repository's push record, the cloud provider's trail. Those you control, and they are what audit trails for agent actions is built on.
Do these three this quarter. Collect every MCP client config from managed endpoints and count the distinct servers — most teams discover a number they did not expect, and the count alone usually settles the argument about whether this needs a policy. Publish a short allowlist with pinned versions and ship it as managed configuration, so the install decision stops being per-developer. Then run the curl check above against each allowlisted server that listens on a port, and drop any that answers 200. The servers that speak stdio need no test — they need the review, because the review is the only control they have.