
Testing MONAI Label Deployments for Unauthenticated API and Tooling Exposure
The story that landed in my feed was framed around AI agents exploiting a MONAI Label zero-day on medical-imaging research servers. That framing is the least useful part of it. The useful part for defenders is that a research annotation server is a production API with a small user base, and most deployments are treated like internal tools rather than systems that store patient imaging. This post is the defensive testing walkthrough I run instead for MONAI Label deployments: how to inventory the deployed version and reachable API surface, test unauthenticated access with bounded probes, check the gateway-to-backend boundary, review tooling exposure, and confirm the telemetry can distinguish a routine request from an exploitation attempt.
I did not stand up an internet-facing MONAI Label deployment for this post, and I'm not going to pretend I did. What follows is the review I run before a research server is allowed near anything real: inventory, exposure matrix, bounded anonymous probes, boundary checks, and telemetry that can actually answer "was this a request or an exploitation attempt?" Where you see output, it is illustrative lab output, not captured production evidence.
On this page
What the MONAI Label exploitation reports establish — and what they leave unknown
Preserve the reporting chain and timeline
The supplied reporting contains two items:
| Publisher | Headline (as supplied) | Publication timestamp (from the supplied feed) |
|---|---|---|
| SecurityWeek | Amazon: China-Linked Hackers' AI Agents Exploited Medical Software Zero-Day | 2026-11-21T12:08:50Z |
| Cloud Security Alliance | MONAI Label Zero-Day: AI Agents Exploit Medical Imaging Research Servers | 2026-11-22T02:23:51Z |
Both arrived as Google News redirect links — what a news seed looks like, not what a primary advisory looks like. The timestamps are RSS publication metadata exactly as the supplied feed provided them. They are not verified incident dates, and I did not independently open either article while writing this. The two stamps are about fourteen hours apart, which is consistent with one outlet following the other. But fourteen hours of feed metadata proves nothing about who reported first, and even less about when an intrusion started.
That distinction matters for defenders. A reporting chain gives you the shape of a claim; only an upstream advisory — from the MONAI Label maintainers or whoever runs the affected environment — gives you versions, endpoints, and fix status.
Separate reported exploitation from unverified mechanics
Here is what I am willing to treat as reported, and what I am not.
| Claim | Status in this post |
|---|---|
| A MONAI Label zero-day was exploited | Reported, attributed to the supplied CSA and SecurityWeek items |
| Amazon attributed the activity to China-linked actors | Reported, attributed; I have not seen Amazon's own statement |
| "AI agents" were involved in the exploitation | Reported as a characterization; the mechanism is undefined |
| A specific CVE identifier exists | Unknown — the seed contains none, so I do not invent one |
| Specific affected MONAI Label versions | Unknown — not established by the supplied material |
| A specific vulnerable endpoint or exploit primitive | Unknown — not established by the supplied material |
| Patch status, fixed version, or vendor advisory | Unknown — no upstream advisory is present in the seed |
| Lateral movement into imaging systems or cloud accounts | Unconfirmed — I will not assert it |
| Degree of attacker autonomy (model-driven vs. scripted automation) | Unresolved by the supplied reporting |
The last row is the one I would push back on hardest. "AI agents exploited a zero-day" reads as model-driven discovery and exploitation. In practice the same sentence gets used for a retry loop with a tool-calling wrapper around a vulnerability scanner. Automation is not autonomy, and the supplied material does not distinguish them. You can read a plausible mechanism into a headline in about ten seconds; the work is in not doing that.
Treat every claim in the table's "Unknown" rows as unknown in your own write-ups too. If you file a report that says "MONAI Label CVE-XXXX was exploited via /some/endpoint," you have invented two facts and the report is now unusable.
Map MONAI Label research-server trust boundaries before testing
Trace the MONAI Label deployment across five trust boundaries
The typical MONAI Label deployment shape looks like this. This is the standard architecture I review, not the architecture of the reported incident — I do not know that architecture.
annotator workstation (3D Slicer plugin / OHIF / browser)
│ HTTPS
▼
[B1] ingress or reverse proxy ── TLS termination, authentication, header injection
│
▼
[B2] MONAI Label server (container, HTTP listener on a port)
├──► application code under the app directory (tasks, configs)
├──► [B3] datastore (local volume, or DICOMweb client to a PACS)
├──► model checkpoints on disk (loaded by the ML framework)
└──► [B4] job runner for inference and training workloads
│
▼
[B5] object store, PACS/VNA, cloud identity, outbound egress
Five boundaries are worth naming, because each is a separate question in a review:
- B1 — client to ingress. Who can reach the proxy at all, and does it authenticate before routing?
- B2 — ingress to backend. Is the backend listener reachable only through the proxy, or directly as well?
- B3 — application to datastore. Does the server hold read-write access to a shared share or bucket that contains more than the requesting user's studies?
- B4 — application to job runner. Can a request start a workload, and under what identity and limits?
- B5 — application to downstream. What credentials sit in the container's environment, and where can the container open outbound connections?
Most "research server got exploited" outcomes collapse into B1, B2, or B4. You do not need a zero-day for B2.
Define an authorized test scope for the lab deployment
Before any request leaves a shell, write these down and get them acknowledged:
- Isolated deployment. A staging or lab instance with its own credentials. Same image, same app configuration, no shared storage with production.
- Synthetic imaging data. Small phantom volumes or a public sample set. No real patient records, ever, including "just one study to check the datastore listing."
- Disposable credentials. A lab identity-provider client and a lab service account that can be deleted the same day.
- Explicit host allowlist. Named hosts and ports, in the test plan. If the target is not on the list, it is not tested.
- Excluded operations. Training jobs, model execution against large volumes, upload and delete operations, any request that mutates a datastore entry, and anything that could exhaust GPU memory on a shared node.
The out-of-scope list is the part people skip. Training and inference endpoints turn an access-control finding into a denial-of-service finding, so keep them out of the first pass and test them deliberately later, if at all.
Establish the deployed MONAI Label version and reachable API surface
Collect a defensible MONAI Label deployment inventory
A finding you cannot attach to a version is a finding nobody can fix. Record these without dumping secrets into your notes:
# image identity
docker inspect --format '{{.Config.Image}}' monailabel
docker image inspect --format '{{index .RepoDigests 0}}' "$(docker inspect --format '{{.Config.Image}}' monailabel)"
## package version inside the running container
docker exec monailabel pip show monai-label | sed -n '1,3p'
docker exec monailabel python -V
## startup arguments and config, minus anything secret-shaped
docker inspect --format '{{json .Config.Cmd}}' monailabel
docker inspect --format '{{json .Config.Env}}' monailabel | jq -r '.[] | select(test("KEY|TOKEN|SECRET|PASS|CRED"; "i") | not)'
## published ports: the B2 question, answered early
docker port monailabelIllustrative output shape — the version string is a placeholder because yours is the one that matters:
Name: monai-label
Version: <installed version>
Summary: MONAI Label is an intelligent open source image labeling and learning tool.
{"0.0.0.0:8000/tcp":"0.0.0.0:8000"} # backend published on all interfaces — investigate
That last line is the kind of thing the inventory exists to catch. A backend port published to 0.0.0.0 on the host, with an ingress in front of it, means the ingress is decorative. Also capture: ingress rules for this hostname, the load-balancer target group, firewall policy for the port, the application name and config file path passed at startup, and relevant ML dependency versions (framework, image libraries) since model file loading touches them.
Do not paste the environment dump into a ticket. Copy it to a restricted location, review it, and record only the key names.
Discover API routes from the installed MONAI Label application
Route names change between versions, and guessing them wastes time and pollutes logs. Get the real table from the installed code. In the versions I have worked with, the MONAI Label server is FastAPI-based, so if the deployment exposes an OpenAPI document, that is the fastest source of truth — but confirm rather than assume, since documentation endpoints get turned off:
BASE=http://127.0.0.1:8000
## only meaningful if the deployment serves an OpenAPI document
curl -sS --max-time 5 "$BASE/openapi.json" | jq -r '.paths | keys[]' | sort
## fallback: read the installed route registrations directly
SRC=$(docker exec monailabel python -c 'import monailabel,os;print(os.path.dirname(monailabel.__file__))')
docker exec monailabel grep -rInE '@(app|router).(get|post|put|delete)|add_api_route' "$SRC"A 404 from openapi.json is a configuration choice, not a vulnerability — and hiding it later is not a fix either. A 200 to an anonymous request is not a vulnerability by itself, but it is an inventory shortcut for you and for anyone else.
Build an exposure matrix for the reachable API
Classify every discovered operation before you send a single request to it:
| Operation family | Anonymous reachable (observed) | Authn | Authz check | Data sensitivity | Side effects | Intended audience |
|---|---|---|---|---|---|---|
| Server metadata / health | yes | none observed | n/a | low | none | monitoring, clients |
| Datastore listing and fetch | ? | ? | ? | high | none | annotator clients |
| Inference request | ? | ? | ? | high | high (GPU) | annotator clients |
| Training / job control | ? | ? | ? | medium | high | operators only |
| Model or bundle upload/download | ? | ? | ? | medium | high | operators only |
| Docs / static assets | yes | none | n/a | low | none | developers |
Fill the question marks with evidence, not with expectations. Group the tooling surfaces — extensions, job control, upload paths, filesystem-facing endpoints — into their own block. They have different side effects and different audiences than the read path, and lumping them together produces findings like "the MONAI Label API is exposed," which helps nobody.
Test unauthenticated API access without invoking sensitive operations
Start with bounded curl probes against read-only routes
Read-only, operator-confirmed lab routes only. No redirects followed, short timeouts, response bodies discarded so that imaging data never lands in your shell history or scrollback:
HOST="lab-monai.example.internal" # must be on the authorized allowlist
ROUTE="/info" # operator-confirmed read-only route
curl -sS -o /dev/null -D /tmp/probe.headers --max-time 5 --max-redirs 0 -H 'Accept: application/json' -H 'X-Lab-Probe: hjlab-0001' -w 'status=%{http_code} bytes=%{size_download} ms=%{time_total}
' "https://${HOST}${ROUTE}"
grep -iE '^(content-type|www-authenticate|location|x-request-id|server):' /tmp/probe.headersSample probe output from a lab instance:
status=200 bytes=412 ms=0.041
content-type: application/json
x-request-id: 6f1c2a9e-lab
server: nginx
What this tells you: the proxy answered, the backend answered, and the route is anonymously readable. What it does not tell you: whether the route is supposed to be anonymous, whether the backend validated anything, or whether a sibling route behaves the same way. One probe is a data point, not a conclusion.
Compare anonymous, invalid-token, and authorized requests
Consistency across principals is what exposes a broken boundary. A small harness with a hard-coded route list keeps you from drifting into enumeration:
// Bounded anonymous/invalid/authorized comparison.
// Routes are placeholders: copy the ones you already collected in the exposure matrix.
const BASE = process.env.LAB_BASE; // https://lab-monai.example.internal
const TOKEN = process.env.LAB_TOKEN ?? ""; // never printed, never logged
const PROBE = "hjlab-0001";
const ROUTES = ["/info", "/matrix/route-2", "/matrix/route-3"]; // read-only, fixed fixtures
const PRINCIPALS = [
{ name: "anonymous", headers: {} },
{ name: "invalid-token", headers: { authorization: "Bearer eyJhbGciOiJub25lIn0.lab.invalid" } },
TOKEN ? { name: "authorized", headers: { authorization: `Bearer ${TOKEN}` } } : null,
].filter(Boolean);
for (const route of ROUTES) {
for (const principal of PRINCIPALS) {
const started = performance.now();
const row = { route, principal: principal.name };
try {
const res = await fetch(new URL(route, BASE), {
method: "GET",
headers: { ...principal.headers, "x-lab-probe": PROBE },
redirect: "manual", // a 302 to a login page is a finding, not a detour
signal: AbortSignal.timeout(5000),
});
row.status = res.status;
row.authn = res.headers.get("www-authenticate") ?? "-";
row.location = res.headers.get("location") ? "<redirect>" : "-";
await res.body?.cancel(); // discard payload: no image bytes enter this process
} catch (err) {
row.status = err.name; // TimeoutError or AbortError
}
row.ms = Math.round(performance.now() - started);
console.log(JSON.stringify(row));
await new Promise((r) => setTimeout(r, 250)); // stay polite, stay correlatable
}
}Invented lab numbers, real-shaped rows:
{"route":"/info","principal":"anonymous","status":200,"authn":"-","location":"-","ms":41}
{"route":"/info","principal":"invalid-token","status":200,"authn":"-","location":"-","ms":38}
{"route":"/matrix/route-2","principal":"anonymous","status":401,"authn":"Bearer","location":"-","ms":44}
{"route":"/matrix/route-2","principal":"invalid-token","status":401,"authn":"Bearer","location":"-","ms":46}
{"route":"/matrix/route-2","principal":"authorized","status":200,"authn":"-","location":"-","ms":52}
{"route":"/matrix/route-3","principal":"anonymous","status":302,"authn":"-","location":"<redirect>","ms":39}
The row that would matter here is a route-3-style route returning 200 to anonymous and to authorized with different payload sizes. That pattern — same status, different content — is what an unauthenticated data path looks like when nobody finished the authorization check. It is also the pattern a status-code-only review is most likely to miss.
Interpret authentication responses conservatively
| Observation | What it can mean | What it does not prove |
|---|---|---|
200 anonymous | Route is public, or authentication is missing, or the proxy injects identity | That the data returned is sensitive |
401 | Credential absent or rejected at this layer | That a valid credential is authorized for this resource |
403 | Authenticated but denied, or denied by policy at the proxy | Which layer denied it |
404 | Route absent, or route hidden behind auth, or resource not found | That the code path is unreachable |
302 to a login page | Browser-oriented assumption baked into the API | That non-browser clients are stopped |
Access-Control-Allow-Origin: * | Any web origin can read the response if it can authenticate | That authorization is broken — but it turns a stolen token into a cross-origin read |
Two details people skip. First, 401 versus 403 tells you which boundary answered, so record WWW-Authenticate and any x-request-id, not just the number. Second, if the proxy denies with its own branded error page and the backend denies with JSON, the response body shape distinguishes them — which is why you should look at the body for shape on a couple of requests and never store it for the rest.
Check whether the MONAI Label authentication boundary can be bypassed
Compare the gateway path with the direct backend listener
This is the highest-yield check in the whole review, and it is a configuration question, not an exploit:
# host-side: what is actually published?
docker port monailabel
## container-side: what is the process bound to?
docker exec monailabel sh -c 'ss -ltnp 2>/dev/null || netstat -ltnp 2>/dev/null'
## inside an authorized lab host only: does the backend port answer directly?
curl -sS -o /dev/null --max-time 3 --max-redirs 0 -w 'direct status=%{http_code}
' http://10.20.4.11:8000/infoSample result:
0.0.0.0:8000/tcp -> 0.0.0.0:8000
LISTEN 0 2048 0.0.0.0:8000 0.0.0.0:* users:(("python",pid=1,fd=6))
direct status=200
If the backend answers directly from a network that should only reach the proxy, every authentication control from the previous section is optional for anyone who finds that port. Fix order: stop publishing the port, bind the listener to the pod or loopback interface, and put a network policy or firewall rule in front of it. Do not rely on the ingress to be the only route in.
Inspect identity propagation from proxy to backend
Next question: does the backend actually validate anything, or does it trust whatever the proxy hands it? Two common shapes:
- Validating backend. The proxy forwards the user's token and the application verifies signature, issuer, and audience. Spoofed identity headers do nothing.
- Trusting backend. The proxy authenticates, then injects
X-Auth-Request-Useror similar, and the application trusts it. This is fine only if the proxy overwrites client-supplied copies of that header and the backend is unreachable except through the proxy.
nginx's proxy_set_header replaces a client-supplied header rather than appending, which is why that pattern is common and usually works. The failure modes are the ones to test for in the lab:
- A proxy configured to append or pass through the header, leaving the client's value intact.
- A path that reaches the backend without traversing the auth subrequest, such as a path-prefix that is excluded from the auth block.
- A second listener, sidecar, or health endpoint that the proxy never sees.
Review this as configuration, not as a live bypass: dump the ingress or virtual-service config for the host, find every route and every excluded path, and confirm the header set on each. Keep the result as "the backend trusts header X, and here is the config that guarantees overwrite" — that is auditable and safe. The version of this check I will not write is a recipe for injecting that header against someone's real deployment.
Separate authentication from resource authorization
Being logged in is not the same as being allowed to read a specific study. Use two synthetic lab identities and two fixture resources:
| Test | Expected if isolation exists | What a failure actually means |
|---|---|---|
| User B fetches fixture owned by User A | 403 or 404 | Missing resource-level authorization |
| Anonymous lists datastore entries | 401 or an empty scoped result | Shared-tenant read path |
| User B submits a job tagged for User A | 403 | Job control has no tenancy |
| User A reads own fixture | 200 | Sanity check — include it, or you cannot read results |
Be honest about the design. MONAI Label is frequently deployed as a single-tenant research service: one datastore, one team, one shared credential. If that is the deployment's intent, per-user isolation may simply not exist, and the honest finding is "no resource-level isolation is implemented; tenancy is enforced entirely by network placement," not "IDOR." That sentence points at the real fix — separate deployments per tenant — instead of a bug ticket that gets closed as by-design.
Review tooling exposure without exercising an exploit
Inventory enabled capabilities from configuration and code
Read what is switched on rather than assuming. The application directory contains the task configuration, and the container's startup arguments control which app is loaded and where the datastore lives. Enumerate:
- which application is loaded, and which of its tasks are enabled;
- whether training is permitted, and whether job state is persisted;
- whether model or bundle upload is exposed and where files land;
- whether a filesystem-facing endpoint exists for listing or downloading;
- whether extra extensions or Python dependencies were installed into the image.
Do not assert that all MONAI Label deployments expose any of these. Your deployment's answer comes from its own config and its own route table.
Trace request inputs to privileged effects
Now follow the data. Greps are a fine starting point because they are readable in a review and provably inert:
SRC=$(docker exec monailabel python -c 'import monailabel,os;print(os.path.dirname(monailabel.__file__))')
## path construction from request-derived values
docker exec monailabel grep -rInE 'os.path.join|Path(' "$SRC" | grep -iE 'study|image|model|file|name'
## process and job execution boundaries
docker exec monailabel grep -rInE 'subprocess|Popen|check_output|sys.executable' "$SRC"
## model loading (deserialization surface)
docker exec monailabel grep -rInE 'torch.load|joblib.load|pickle.load' "$SRC"For each hit, answer four questions:
- Validation. Is the request value constrained to a known identifier, or concatenated into a path?
- Execution boundary. Does the value reach a subprocess, a container, or a deserializer?
- Identity. What service account or cloud role does that execution path run under?
- Limits. Is there a CPU, memory, GPU, time, or concurrency cap on the resulting work?
Question four is the one that gets ignored. An inference endpoint with no concurrency limit is a denial-of-service primitive with a friendly name, whether or not any authorization is broken.
Also check the container itself: running as root, --privileged, a mounted container runtime socket, or write access to a host path all convert a modest application bug into host compromise. Those are one-line findings with large consequences, and they take ten seconds to check.
Explain impact without upgrading exposure into compromise
Keep the ladder explicit and require separate evidence for each rung:
| Exposure | Evidence needed | Impact ceiling |
|---|---|---|
| Metadata disclosure | Anonymous 200 on the info route, body shape captured | Version and configuration leakage |
| Unauthorized image access | Anonymous or cross-user fetch of a fixture study | PHI exposure — the serious one |
| Unauthorized job submission | Fixture job created by an unprivileged principal | Compute abuse, cost, noisy neighbour |
| Resource exhaustion | Capacity metric moved under bounded, authorized load | Availability loss |
| Code execution | A reproduced path from input to executed code | Full compromise of the workload |
Evidence for one rung does not transfer upward. An anonymous /info response is metadata disclosure, full stop. Writing it up as "unauthenticated access to the AI platform" is how reports lose credibility with the team that has to fix it.
Verify network isolation and limit the blast radius
Test intended network paths with an allowlist
Reachability testing here means "does the path I designed work," not "what else is out there." Use a fixed list of approved addresses and report allow/deny per pair:
# approved address list only — no discovery, no scanning, no port ranges
for pair in "10.20.4.11 443" "10.20.4.11 8000" "10.30.9.7 11112"; do
set -- $pair
if timeout 3 bash -c "</dev/tcp/$1/$2" 2>/dev/null; then
echo "ALLOW $1:$2"
else
echo "DENY $1:$2"
fi
doneSample result from three networks (annotator VLAN, management VLAN, isolated test VLAN):
## annotator VLAN
ALLOW 10.20.4.11:443
DENY 10.20.4.11:8000 # expected: backend not routable from client network
## management VLAN
ALLOW 10.20.4.11:8000 # expected: operators reach the backend directly
## isolated test VLAN
DENY 10.20.4.11:443
DENY 10.30.9.7:11112 # expected: no path from untrusted segment to DICOM
The management VLAN allowing direct backend access is usually intentional. Write it down as a documented exception with a named owner, because undocumented exceptions are what future reviewers "discover" and escalate.
Inspect downstream access from the application process
Assume an attacker already reached the application process, then ask what that process can touch:
- Storage mounts. Is the datastore a read-write mount of a share that also holds clinical data? Can the process delete studies?
- Imaging-system credentials. Are PACS or DICOMweb credentials in environment variables or a mounted config? What can that account query — one study, or the whole archive?
- Cloud identity. What does the workload's role permit? Read-only on a prefix is very different from write on a bucket plus role assumption.
- Egress. Is outbound traffic restricted? An application container with unrestricted egress can reach a model registry, and it can also reach an attacker's endpoint.
Excessive downstream privilege does not prove lateral movement occurred in the reported incident. I have no evidence about that, and the supplied reporting does not describe it. What I can say is that over-privileged service accounts raise the ceiling of any single application bug from "this container" to "the archive."
Build telemetry that distinguishes requests from exploitation
Correlate ingress, application, identity, and runtime evidence
A useful record set per request:
| Field | Why it exists |
|---|---|
request_id | Ties proxy, app, and identity logs together |
principal | Which identity, or anonymous — logged as a subject, not a token |
route + method | What was asked for, normalized to the route template |
status | Outcome at each layer |
authz_decision | Allowed/denied plus the policy that decided |
tenant / study_ref | Which fixture or resource, as a reference not a path |
job_id | Correlates a request to the workload it started |
process_activity | Subprocess spawns, model loads, file writes |
egress_destination | Outbound host and port, if you can capture it |
Never log bearer tokens, cookies, authorization headers, or imaging payloads. Log the subject identifier from the validated token instead, and log resource references, not paths.
Generate a harmless validation event and find it in every log
Send one uniquely tagged request that you expect to be denied, then go find it in every log you have:
curl -sS -o /dev/null --max-time 5 --max-redirs 0 \
-H 'X-Lab-Probe: hjlab-validation-0001' \
-w 'status=%{http_code}\n' \
https://lab-monai.example.internal/matrix/route-2
Invented records, correctly shaped:
## ingress access log
2026-01-01T10:00:00Z 10.20.4.55 GET /matrix/route-2 401 req=6f1c2a9e
## proxy auth decision
2026-01-01T10:00:00Z req=6f1c2a9e decision=deny reason=token_absent principal=anonymous
## application log
2026-01-01T10:00:00Z INFO request completed status=401 <-- no request id, no principal
That last line is the common and important finding: the ingress can prove a request was denied, but it cannot tell you what the application did with it. If the application log has no request identifier and no principal, you cannot answer "did this denied request reach a handler?" — which is the question an incident review actually asks. Fix the log fields before you need them.
I did not execute this walkthrough against a live deployment for this post, so I am not going to show a captured production trace. The above is the record structure to build toward, not evidence I collected.
Assess AI-assistance claims separately
Application and ingress logs can establish request timing, inter-arrival distributions, breadth of routes touched, retry behaviour, and whether user-agent strings and headers were consistent. They can support a statement like "the traffic pattern is consistent with automated tooling rather than manual use."
They cannot establish that a language model was involved. They cannot establish attribution. And they cannot establish that a model discovered the vulnerable path or decided to exploit it. Those claims need different evidence — model endpoints, tool-calling logs, or the operator's own account — and the supplied reporting, as I received it, does not include that evidence. Amazon's attribution is Amazon's claim; the autonomy framing in the headlines is a characterization on top of it.
Prioritize containment, remediation, and regression checks
Fix reachability and authorization first
Ranked by effort-to-impact, which is how I would sequence the work:
- Remove unintended public reachability. If the service is meant for a VPN or a research network, make the ingress say so. This is minutes of work and removes whole classes of attackers.
- Close the direct backend path. Unpublish the port, bind to the pod interface, add a network policy. This restores the trust boundary the design assumes.
- Enforce identity and resource checks. Validate tokens at the backend, or guarantee header overwrite at the proxy and unreachable backend. Add tenancy checks if the deployment hosts more than one tenant.
- Disable what you do not use. Training, upload, extension loading, and documentation endpoints are capability you are not being paid to expose.
- Drop privileges. Non-root user, read-only root filesystem, no runtime socket, least-privilege service account, scoped datastore mount.
- Restrict egress. Allowlist the model registry, the PACS, and the object store; deny the rest.
Hiding the API documentation is not on this list and belongs nowhere near the top. It changes what an attacker has to read, not what they can do. I have seen that change shipped as a "security fix" more than once; it is a cosmetic edit to a discovery aid.
Handle a suspected incident and vendor remediation
If you believe a deployment was touched:
- Preserve ingress, proxy auth, application, identity-provider, and runtime logs before rotating anything.
- Snapshot or isolate the container image and its filesystem for review; keep the digest you recorded during inventory.
- Assume credential exposure for anything in the container environment: PACS/DICOMweb credentials, cloud keys, datastore tokens. Rotate them, then check what they could reach.
- Determine the data exposure question separately: which studies could that process read, and was there evidence of reads?
- Follow upstream guidance from the MONAI Label maintainers once an advisory exists. I will not name a fixed version here, because no advisory was in the supplied material and inventing one is worse than useless.
Configuration hardening is not a patch for a code vulnerability. If the reported exploitation involved a flaw in the software itself, network restrictions reduce exposure but do not remove the defect.
Keep the inventory you built in this review. When an advisory does land, the first question is "are we on an affected version," and the digest, package version, and startup arguments answer it in under a minute.
Turn findings into release gates
These repeat on every deploy and take a few minutes on a staging instance:
- Anonymous-access matrix re-run against the new image, with the expected-row snapshot diffed.
- Direct-reachability check: backend port denied from the client network, allowed only from the documented management path.
- Network path test from each segmented network to each approved service address.
- Synthetic-user isolation check, or an explicit assertion that the deployment is single-tenant.
- Denial observability: a deliberately denied request must produce a correlated log line with a request id and a principal.
That last gate is what keeps the other four honest. If you cannot see a denial, you will not see an exploitation attempt either.
Record conclusions and source limitations
Report confirmed findings separately from open questions
Structure the write-up in two blocks, and resist the urge to blend them.
What a review like this can confirm — the deployed version and image digest, the published ports and listener bindings, the actual route table, which routes answered anonymously, whether the proxy or the backend made each denial, what the backend trusts for identity, the scoped permissions of the datastore and cloud credentials, and which capabilities were enabled.
What remains open from the reporting — no CVE identifier, no affected version range, no confirmed vulnerable endpoint or exploit primitive, no patch status, no verified incident timeline, and no evidence resolving how autonomous the tooling actually was. The dates in the seed are publication metadata, not incident dates, and I did not independently verify either article.
Rank findings by demonstrated privilege and data exposure. Anonymous read access to a study datastore outranks a metadata-disclosure route no matter how alarming the metadata route sounds, and both outrank anything you can say about AI agents. The AI framing is the part of this story least likely to change what you deploy tonight. The B2 boundary — a backend listener reachable around its proxy — is the part most likely to be broken right now.
Further Reading
- Supplied secondary reporting (Google News redirect links as received; I did not verify the destination articles): Cloud Security Alliance — "MONAI Label Zero-Day: AI Agents Exploit Medical Imaging Research Servers" and SecurityWeek — "Amazon: China-Linked Hackers' AI Agents Exploited Medical Software Zero-Day".
- MONAI Label documentation — deployment and client setup for the server you are reviewing.
- Project MONAI on GitHub — source and issue tracker for verifying route and configuration behaviour against your installed version.
- OWASP API Security Top 10 (2023) — the broken-object-level-authorization and unrestricted-resource-consumption entries map directly onto the checks above.
- nginx
proxy_set_header— read this before relying on header injection as an authentication boundary. - Kubernetes NetworkPolicy — the mechanism for closing the direct-backend path in a cluster deployment.
I could not verify a permalink to Amazon's original statement or to an upstream MONAI Label advisory, so neither is linked here. Both are worth chasing before you write your own version of this story.
More posts

What the Chrome 157.0.8103.50 Update Fixes in CVE-2026-125350, and How to Confirm It Is Applied
Google patched actively exploited Chrome zero-day CVE-2026-125350 in version 157.0.8103.50; this walkthrough explains the fix and verifies deployment.

Validating the PHP2Shell Fix: Testing Whether phpAfterShell Actually Crosses the RCE Boundary
A practical deep-dive into validating the PHP2Shell patch by mapping the original RCE boundary, probing alternative phpAfterShell paths, and converting bypass cases into regression tests.

Testing Inkling 2 Mini’s Laptop Coding-Agent Claim with a Node.js Harness
Build a reproducible Node.js harness to independently test Inkling 2 Mini’s local coding-agent claims by measuring task completion, peak memory, end-to-end latency, and energy use against a conventional local model and hosted API.
Loading comments…