GHSA-9x8x-crjq-g64h (CVE-2026-77359, critical, CVSS 4.0 score 9.3) reached the GitHub Advisory Database on November 20, 2026, after NVD published the CVE on November 19. Versions of the jupyter-mcp-server pip package up to and including 1.0.2 let a malicious website use DNS rebinding to reach the server's management routes and swap the Jupyter backend it talks to. The first patched version is 1.0.3. If you run Jupyter MCP Server in standalone streamable-http mode, update and check how it is bound. If your agent launches it over stdio, the browser path in this advisory does not apply.
The interesting part is not the DNS trick, which is well known. It is that the server already knew how to defend /mcp, and the protection stopped at that one route. That is a pattern worth checking in any local HTTP tool your coding agent depends on.
TL;DR
| Question | Answer |
|---|---|
| Am I affected? | If you run jupyter-mcp-server 1.0.2 or older in standalone streamable-http mode. |
| Is there a fix? | Yes: 1.0.3 (release notes, pull request 262). |
| What can an attacker do? | Replace the active Jupyter backend (runtime_url, document_url, tokens) via PUT /api/connect, making the server open kernel and WebSocket connections to attacker infrastructure; stop the current notebook via DELETE /api/stop. |
| Does the attacker need my token? | No. The page sends browser-shaped requests; the advisory's PoC ran against a server with MCP_TOKEN set. |
| Does data leave my machine? | The server sends Jupyter API traffic, including the token the attacker supplied, to the attacker-chosen backend. The advisory does not describe your own notebook data being read. |
| Exploited in the wild? | The advisory describes a proof of concept and does not report in-the-wild use. |
What is CVE-2026-77359?
The advisory says standalone streamable-http mode in datalayer/jupyter-mcp-server "rejects forged Host and Origin headers on /mcp, but custom management routes mounted on the same application do not get the same browser-origin protection." The code in question is jupyter_mcp_server/server.py: a PUT /api/connect route that parses the caller's JSON, calls set_config with the supplied runtime_url, document_url and tokens, resets ServerContext and starts a kernel client. A DELETE /api/stop route removes the current notebook.
The advisory shows the contrast directly. With MCP_TOKEN set, a POST /mcp carrying Host: attacker.example:8083 and a forged Origin returns HTTP 421 Invalid Host header. The same header shape sent to PUT /api/connect returns 200 OK with {"success":true}.
The package is on PyPI as jupyter-mcp-server; the advisory lists <= 1.0.2 as vulnerable and 1.0.3 as patched. NVD tracks the CVE at CVE-2026-77359. Beam's CVE database does not have a page for this entry yet.
How does the attack work, step by step?
- The victim visits an attacker page. It loads JavaScript from
attacker.example. - The attacker's DNS answer changes. The hostname now resolves to
127.0.0.1or to a private address where the MCP listener lives (a LAN host, a VPN address, a Docker-published port). - The browser reconnects to the new address. It still treats the origin as
attacker.example, so the page can read responses. - The page sends
PUT /api/connectwithHost: attacker.example:<port>and an attacker-chosen JSON body:runtime_url,document_url,document_idand tokens pointing at a server the attacker controls. - The management route accepts it. No Host or Origin check, and the advisory's remediation list asks for the
MCP_TOKENbearer token on these routes, which implies the route did not require it. - The MCP server starts a kernel client against the attacker's backend. The advisory's log excerpt reads "Connect endpoint received", then "Starting the kernel client...". An attacker listener received
POST /api/kernelswithAuthorization: Bearer ATTACKER_TOKEN_REBINDand a WebSocket request to/api/kernels/<id>/channels.
From then on, the agent's notebook tools would talk to a backend the attacker chose. The advisory demonstrates the redirect and the outbound connections; it does not claim code execution on the victim machine. Think of what that means in practice, though: an agent that believes it is running cells in your notebook is running them (or receiving results) elsewhere, so what it reads back is attacker-controlled output. That is my reading of the mechanism, not a finding stated in the advisory.
The advisory is careful about what is and is not claimed. It says this "is not a generic claim that /mcp lacks Host validation," and that the default bind alone is not the cause: "The default 0.0.0.0 bind increases exposure, but the browser-origin boundary failure is that state-changing custom routes bypass the Host/Origin controls applied to /mcp."
Why does a notebook backend swap matter for agents?
Jupyter MCP Server exists so a coding agent can read, edit and run notebook cells through MCP tools. The server holds the connection settings, meaning which Jupyter server, which notebook and which token. Whoever can rewrite those settings decides where the agent's code and reads end up.
That makes /api/connect more than a configuration endpoint. It is the switch that points the agent's tools at a different machine. An attacker who controls the backend can log the bearer token the server sends, observe the code the agent submits, and return output the agent then reasons over. None of that needs a bug in the model or a prompt injection; it needs one unprotected HTTP route and a browser tab.
The /api/stop route is a smaller problem, but it is a reliable way to interrupt a running session: a page you visit can remove the current notebook from the server's manager without you clicking anything.
What did 1.0.3 change?
Pull request 262, "Protect management routes," was merged on July 11, 2026 and appears in the v1.0.3 release notes, which are dated July 11. The advisory itself only reached the GitHub Advisory Database now. The pull request description says the patch adds a security middleware for the management routes that:
- rejects non-local
Hostvalues on/api/connect,/api/stopand/api/healthz(returns421 Misdirected Request); - rejects non-local browser
Originvalues on those routes (403 Forbidden); - requires the configured
MCP_TOKENfor the state-changing/api/connectand/api/stop(401 Unauthorizedotherwise); - keeps
/api/healthzavailable for local readiness checks; - updates the first-party
connectandstopCLI commands to sendAuthorization: Bearer $MCP_TOKEN.
The advisory's own remediation list goes further and suggests binding standalone HTTP to 127.0.0.1 by default with an explicit allowlist for non-loopback listeners. I did not verify whether 1.0.3 changed the default bind, so check the release notes and your own --host setting rather than assuming.
Note the gap between the fix date and the disclosure date. Anyone who updated in July got the fix without a CVE to tell them; anyone who pinned an older version and relies on advisory feeds is hearing about it only today.
What this means if you run AI coding agents
1. Find out how the server starts. An MCP config entry with command and args launches it as a child process over stdio. An entry with a url such as http://localhost:8083/mcp, a Docker container publishing a port, or a terminal where you ran python -m jupyter_mcp_server --transport streamable-http means you run the HTTP mode.
2. Check the version. Typical commands: pip show jupyter-mcp-server or pip list | grep jupyter-mcp-server. You want 1.0.3 or later. Upgrade with pip install -U jupyter-mcp-server, or pull a current container image if you use Docker.
3. Set a token and a narrow bind. The advisory's reproduction used --mcp-token/MCP_TOKEN. Even with the fix, run HTTP mode with a token, and bind to loopback unless you need remote access. If you publish a Docker port, publish it as 127.0.0.1:PORT:PORT.
4. Look in the logs. Search the server output for "Connect endpoint received" lines whose runtime_url or document_url is not the Jupyter server you configured, and for a kernel start you did not trigger. Also check outbound connections from the server process to unfamiliar hosts.
5. Treat tokens as burned if you see anything odd. The advisory's PoC shows the server sending a bearer token to the attacker's backend; that token was one the attacker supplied. Still, rotate your real Jupyter token if you suspect the server was repointed and then reconfigured with real credentials.
6. Audit other local HTTP MCP servers. The bug class repeats. Compare route by route: does every route, not only /mcp, validate Host, validate Origin and require a caller secret? A quick check on a server you own is curl -i -X PUT -H "Host: evil.example" -H "Origin: http://evil.example" http://127.0.0.1:<port>/<management route>. A server that answers instead of rejecting is a candidate. Only run it on your own machine.
7. Prefer stdio for local tools. It removes the browser from the picture.
What developers are saying
There was no Hacker News discussion of this advisory when we checked, so there are no community mitigations to relay yet. For the earlier Todoist advisory on the same class, see our Todoist MCP DNS rebinding post.
What Beam can and cannot do here
Beam is local, privacy-first security and observability for AI coding agents. Its documented MCP scan, beam scan .mcp.json --mcp, runs offline heuristic checks on an MCP config, including a version-pin check, as described in the scanning docs. That is useful for inventory: it helps you see which MCP entries you have and whether a package is pinned to a version you can compare against an advisory.
The limits are real. The scan does not start the server, does not probe its routes, and does not know that 1.0.2 is vulnerable. The attack here comes from a web page to a local port, not from your agent's tool calls, so Beam's hook-based deny on Claude Code and Codex PreToolUse does not see it. Update the package and fix the bind; use Beam to keep the inventory honest. For background, read our practical MCP security guide and see how Beam keeps data on-device.
Context: local MCP servers keep trusting "local"
This is the second DNS rebinding advisory against a local MCP server in two days. The Todoist MCP server skipped Host and Origin validation altogether. Jupyter MCP Server did the work for /mcp and missed the rest of its own app. Earlier this month, an AWS bulletin covered an SSRF in mcp-gateway-registry, and in October Node.js shipped a security release affecting MCP servers.
The MCP project's transport specification tells local HTTP servers to validate Origin, bind to 127.0.0.1 and authenticate connections. The lesson from this advisory is to apply those rules at the application level, not per route: put the check in middleware that wraps everything the app serves, so a route added later is covered by default. Tools that can start kernels, run notebook cells or reconfigure their own backend deserve the same care as any network service.
Frequently asked questions
What is CVE-2026-77359?
It is a critical flaw in datalayer/jupyter-mcp-server, tracked as GHSA-9x8x-crjq-g64h. In standalone streamable-http mode the /mcp endpoint rejected forged Host and Origin headers, but the custom management routes /api/connect and /api/stop did not, so a website using DNS rebinding could change the server's active Jupyter backend.
Which versions of jupyter-mcp-server are affected and what is the fix?
The advisory lists the pip package jupyter-mcp-server at version 1.0.2 and older as vulnerable, and 1.0.3 as the first patched version. The fix is pull request 262, "Protect management routes", shipped in the v1.0.3 release.
Am I affected if I run Jupyter MCP Server over stdio?
The advisory describes standalone streamable-http mode, where custom HTTP routes are mounted next to /mcp. A stdio launch from your MCP client does not open that HTTP listener, so the browser path does not apply. Check how your configuration starts the server.
Does binding to 127.0.0.1 protect me from DNS rebinding?
No. DNS rebinding keeps the attacker's origin in the browser while the hostname resolves to 127.0.0.1, so loopback binding alone does not help. The server must validate Host and Origin or require a bearer token. The advisory also notes that the default 0.0.0.0 bind widens exposure to LAN, VPN and Docker-published ports.
How do I know whether someone changed my Jupyter backend?
The advisory's proof of concept shows the server log line "Connect endpoint received" with a runtime_url you did not set, followed by "Starting the kernel client". Look for that in your server logs and for unexpected outbound connections from the MCP server process. The advisory does not report exploitation in the wild.
What is the difference between this and the Todoist MCP DNS rebinding bug?
Both are DNS rebinding against a local MCP HTTP server. Todoist's server skipped Host and Origin checks entirely, while Jupyter MCP Server enforced them on /mcp but forgot the custom management routes mounted on the same app.
Related reading
- CVE-2026-76807: Todoist MCP server DNS rebinding
- MCP security: a practical guide
- CVE-2026-125926: AWS mcp-gateway-registry SSRF
- Node.js October 2026 security release and MCP servers
Primary sources: GitHub advisory GHSA-9x8x-crjq-g64h, NVD record for CVE-2026-77359, jupyter-mcp-server v1.0.3 release, pull request 262, MCP transports specification.
Versions, advisory details and fix status are accurate as of November 20, 2026, the day the advisory was published. Check the advisory and the package's release notes for later changes.

