Exposed Jupyter and AI service checks
Brief
Data science teams often start notebook servers such as Jupyter, model servers such as Ollama and experiment trackers such as MLflow with the login off and leave them reachable, so anyone who reaches one can run code or read its data. Read-only API calls prove the exposure; we never start a kernel or a model.
On this page
- Situation
- A position on a network named in the scope letter, internal or a list of external addresses, and the open ports from the first hour's scan (the port scan step shows the method). Every request is a read: no kernel, terminal or model is started, no file is written, and credentials we find are counted, not printed.
- Goal
- A list of AI and data science services that answer without a login, each with its version, what it exposes and a count of the credentials in its files.
- Outputs
- Captured on 5 Nov 2026 in the Atarus Bench review lab, edition
review-lab-0.1: two Jupyter Server 2.15 containers from Debian 13 on an internal Docker network with no route out, one started with an empty token and one with a token, reached from a Debian 13 workbench. Both keep Jupyter's Host check on and accept only their two lab names, so a browser on the capture host could not reach them. The notebooks are fabricated lab files.
Check first
- The ports these services use by default: Jupyter 8888, Ollama 11434, MLflow 5000, Ray's dashboard 8265, TensorBoard 6006 and Gradio 7860, alongside whatever the first hour's scan found open.
- Which hosts the data science and machine learning teams run, from the client's inventory, so a forgotten workstation is not missed.
- That reading an API is in scope and starting anything is not, written in the scope letter.
- Where the results go: a count of credentials per file, never a value.
Steps
Which servers answer without a token?
for h in notebook01 notebook02; do
curl -s -o /dev/null -w "$h %{http_code}\n" "http://$h.corp.example.com:8888/api/status"
done
Expected output
notebook01 200 # <- answers without a token
notebook02 403 # <- asks for a token: the clean case
/api/status needs a login on a Jupyter Server that has one, so its status code sorts the servers in one request each: 200 means anyone who reaches the port is a user, 403 means a token or password is set. The other services answer the same question differently. Ollama has no login of its own, so any answer to /api/version is the finding, and /api/tags lists its models. Ray's dashboard has no login by default and its job API runs commands, so we read /api/jobs/ and never submit one. MLflow has no login unless started with --app-name basic-auth. The lab ran Jupyter only, so these have no captured output.
Negative result. Every server answers 403 or redirects to a login page.
Fix. Never start Jupyter with an empty token (--IdentityProvider.token='' in Jupyter Server 2, the deprecated --ServerApp.token='', or --NotebookApp.token='' in the classic notebook), and look for those flags in container images and start scripts. Put shared servers behind JupyterHub with the company's sign-in, and keep single-user servers on their default 127.0.0.1, reached over SSH, instead of --ip=0.0.0.0.
Which version is it?
curl -s http://notebook01.corp.example.com:8888/api
Expected output
{"version": "2.15.0"} # <- the Jupyter Server version, for the advisories
/api gives the server's version, and it answers whether or not a login is set, so it is worth sending to every candidate, open or closed. The version goes beside the finding with any advisory that affects it.
Negative result. A version with no published advisory that affects it.
What does an open server expose?
curl -s http://notebook01.corp.example.com:8888/api/contents | jq -r '.content[] | "\(.type) \(.path)"'
curl -s http://notebook01.corp.example.com:8888/api/contents/models | jq -r '.content[] | "\(.type) \(.path)"'
Expected output
file README.md
directory models
notebook orders-etl.ipynb # <- every file the server can see is readable
notebook models/churn-training.ipynb
curl -s http://notebook01.corp.example.com:8888/api/kernelspecs | jq -r '.kernelspecs | keys[]'
curl -s http://notebook01.corp.example.com:8888/api/kernels | jq length
Expected output
python3 # <- a Python kernel anyone who reaches the port can start
0
The contents API lists every file under the server's root, and reads or writes any of them for the caller. The kernel lists show a Python kernel available and none running. A POST to /api/kernels would start one, and a message on its websocket channel would run any code as the account the server runs under; where terminals are enabled, /api/terminals gives a shell. That is the finding, and we stop at the list. The report rates it as code execution on that host, on the strength of the listing, without running anything.
Negative result. The calls answer 403, as notebook02 would.
Fix. As above, and run the server as an account with access to its own data only, on a host that cannot reach production databases.
Do the notebooks hold credentials?
curl -s http://notebook01.corp.example.com:8888/api/contents/orders-etl.ipynb \
| jq -r '.content.cells[].source' | grep -cE '://[^:/]+:[^@/]+@'
Expected output
1 # <- one connection string with a password, counted, not printed
Notebooks keep connection strings and keys in their cells, and the contents API returns every cell. The command reads one notebook's source and counts the URLs that carry a user and a password, without printing any. The pattern finds one shape in one notebook's source cells. Run it over every notebook in the listing, over .content.cells[].outputs as well, since printed output often holds what the code read from the environment, and with the key shapes from the git history page. The report names the file and the count, and the client rotates the credential: anyone who reached the port before us could read it in full.
Negative result. A count of 0 for every shape in every notebook's source and output.
Fix. Read credentials from the environment or a secrets store in notebook code (os.environ["DB_URL"]), and strip outputs before a notebook is saved or shared, with jupyter nbconvert --clear-output --inplace or an nbstripout git filter.
The defender sees
The requests come from the tester's address to port 8888, which a flow log or the host firewall's log records. What the server itself records depends on its log level: Jupyter Server logs successful requests at debug, so our reads of the open server do not appear at the default INFO level, while the 403s from the server with a token appear as warnings. We ask the client what the server's log kept for our window. An exposure scan of the client's ranges should have listed these ports; if no one knew the servers were there, that goes in the report beside the finding.
Done when
Every candidate port has had its service's read-only status call without a token, each open Jupyter server has its version, file list, kernel list and credential count recorded, and each server that asks for a login is recorded as such.
Not covered
Captured output for model servers and experiment trackers other than Jupyter, which the page names but the lab did not run, starting kernels or models, prompts sent to a model, and hosted notebook services.