Amazon Threat Intelligence disclosed this week that suspected China-linked threat actors used autonomous AI agents to discover a previously unknown vulnerability in MONAI Label — an open-source server widely deployed for AI-assisted medical image annotation — and then exploited it to gain root access to a university server.
The flaw is an unauthenticated arbitrary file write: an attacker with no account and no credentials can write files outside the server's designated storage folder. It affects MONAI Label 0.8.5 and earlier in the default configuration. No CVE identifier has been published as of this writing, and exploitation is confirmed in the wild — this is not a theoretical risk.
Three things make this incident a watershed moment for defenders:
- Autonomous AI agents are now operationally discovering zero-days. The vulnerability research phase of the kill chain — historically the most expensive and talent-constrained step — is being automated. Expect the window between "niche open-source project" and "exploited target" to collapse dramatically.
- Medical-imaging and research infrastructure is the target. MONAI Label sits at the heart of clinical AI pipelines in hospitals, universities, and research institutes. These servers routinely hold protected health information (PHI), proprietary model weights, and annotated imaging datasets — and they are frequently stood up by data science teams outside formal IT change control.
- The default configuration is vulnerable. If you deployed MONAI Label with defaults (as most quick-start guides instruct), assume exposure until proven otherwise.
If your organization runs MONAI Label — or any derivative of the MONAI project stack (MONAI Deploy, MONAI Bundle serving endpoints) — treat this as an active incident-response scenario, not a patch-when-convenient item.
Technical Analysis
Affected Products and Versions
| Item | Detail |
|---|---|
| Product | MONAI Label (open-source medical imaging annotation server) |
| Affected versions | 0.8.5 and earlier |
| Exposure condition | Default setup — unauthenticated network-reachable instance |
| Vulnerability class | Arbitrary file write outside the storage directory (path traversal / unrestricted file write) |
| Authentication required | None |
| Observed impact | Root-level compromise of a university server |
| Attribution | Suspected China-linked threat actors (per Amazon Threat Intelligence) |
| Discovery method | Autonomous AI agents used by the attackers for vulnerability research |
| CVE | None assigned at time of publication |
How the Attack Works (Defender's View)
MONAI Label runs as a Python-based HTTP service (commonly served via Uvicorn/FastAPI) exposing REST endpoints for uploading imaging studies, running inference, and managing annotation datastores. The flaw allows an unauthenticated remote client to influence the destination path of a file-write operation, escaping the intended datastore directory.
From a defender's perspective, the exploitation chain looks like this:
- Reconnaissance: The attacker identifies internet-reachable MONAI Label instances. Default deployments listen on a predictable HTTP port and expose API routes (e.g.,
/info/,/datastore/,/activelearning/) that return identifying banners and version information. - Arbitrary file write: A crafted request causes the server to write attacker-controlled content to an attacker-controlled path outside the storage folder. Classic weaponization targets on a Linux host running the service as root include:
- Writing a Python file into the application tree and triggering it (code execution via import/route reload)
- Overwriting
~/.ssh/authorized_keysfor persistence - Writing a cron job into
/etc/cron.d/or a systemd unit into/etc/systemd/system/ - Dropping a web-accessible script or modifying application code for a backdoor
- Privilege and impact: Because many MONAI Label deployments run as root (or as a user with broad filesystem rights — frequently inside Docker with a mounted host filesystem), the file write translates directly into root-level code execution, exactly as observed in the university intrusion.
- Post-exploitation: With root on a medical-imaging server, the actor gains access to imaging datasets, connected PACS/research storage, cloud credentials in environment variables or mounted config, and a pivot point into the broader research or clinical network.
Exploitation Status
- Confirmed active exploitation in the wild — a real intrusion against a university server with root compromise.
- No public PoC reported yet, but given the simplicity of unauthenticated file-write primitives, assume independent reproduction is trivial once technical details circulate.
- Not yet in CISA KEV at time of writing — do not wait for KEV inclusion to act. Confirmed exploitation plus unauthenticated remote access is sufficient justification for emergency change windows.
The Bigger Picture: AI-Agent-Driven Vulnerability Discovery
Security teams should internalize the strategic shift: the attackers didn't buy this zero-day or inherit it from a leaked toolkit — their AI agents found it autonomously in a mid-popularity open-source medical project. That means:
- Any niche open-source service you expose is now a candidate for automated zero-day discovery. Your obscure internal tools are no longer protected by obscurity.
- Patch latency is your primary exposure metric. When adversaries automate discovery, your mean-time-to-patch becomes the deciding factor.
- Assume-compromise architecture matters more than ever. Network segmentation, egress filtering, and non-root execution determine whether a zero-day is a contained incident or a breach.
Detection & Response
The detections below target the observable behaviors of this attack chain on Linux hosts running MONAI Label: the Python server process writing outside its datastore, spawning shells, and establishing persistence. Because no public IOCs have been released, these rules focus on technique rather than signatures — tune paths to your actual MONAI installation (--datastore path, install directory, service user).
Sigma Rules
---
title: MONAI Label Server Process Spawning Shell or Command Interpreter
id: 3f8a2c91-7d4e-4b6a-9c21-5e8f0a1b2c3d
status: experimental
description: Detects the MONAI Label / Uvicorn Python server process spawning a shell or command interpreter, consistent with post-exploitation following the unauthenticated arbitrary file write vulnerability affecting MONAI Label 0.8.5 and earlier.
references:
- https://thehackernews.com/2026/11/attackers-ai-agents-found-zero-day-in.html
- https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/11/06
tags:
- attack.execution
- attack.t1059
- attack.initial_access
- attack.t1190
logsource:
category: process_creation
product: linux
detection:
selection_parent:
ParentCommandLine|contains:
- 'monailabel'
- 'monai_label'
- 'uvicorn'
selection_child:
Image|endswith:
- '/sh'
- '/bash'
- '/dash'
- '/zsh'
- '/python'
- '/python3'
- '/curl'
- '/wget'
condition: selection_parent and selection_child
falsepositives:
- MONAI plugins that legitimately invoke external inference binaries or scripting engines; baseline your deployment's normal child processes before alerting at high severity
level: high
---
title: File Write by MONAI Label Process Outside Datastore Directory
id: 9b1e4d72-3a6f-4c85-b7d2-8f1e2a3b4c5d
status: experimental
description: Detects the MONAI Label server process creating or modifying files outside its configured datastore and application directories, a direct artifact of exploiting the path-traversal arbitrary file write flaw. Requires auditd/syscall-level file monitoring.
references:
- https://thehackernews.com/2026/11/attackers-ai-agents-found-zero-day-in.html
- https://attack.mitre.org/techniques/T1505/
author: Security Arsenal
date: 2026/11/06
tags:
- attack.persistence
- attack.t1505
- attack.t1053.003
logsource:
category: file_event
product: linux
detection:
selection_process:
Image|contains:
- 'python'
selection_monai_context:
CommandLine|contains:
- 'monailabel'
- 'monai_label'
- 'uvicorn'
selection_sensitive_paths:
TargetFilename|startswith:
- '/etc/cron'
- '/etc/systemd/system'
- '/root/.ssh'
- '/home/'
- '/var/spool/cron'
- '/etc/profile.d'
- '/usr/local/bin'
- '/tmp/systemd-private'
selection_ssh_keys:
TargetFilename|endswith:
- 'authorized_keys'
- '.service'
condition: selection_process and selection_monai_context and (selection_sensitive_paths or selection_ssh_keys)
falsepositives:
- Administrative maintenance performed through the MONAI host; correlate with change windows. Writes to cron/systemd/SSH paths by the server process should be near-zero in normal operation
level: critical
---
title: New Persistence Artifact in Cron or Systemd Followed by Network Service Activity
id: 5c7d2e83-1b9a-4f46-a8d3-2e7c1b9a4f05
status: experimental
description: Detects creation of cron jobs or systemd unit files by non-package-management processes on hosts running medical imaging or research Python services, a common weaponization path for arbitrary file write vulnerabilities.
references:
- https://thehackernews.com/2026/11/attackers-ai-agents-found-zero-day-in.html
- https://attack.mitre.org/techniques/T1053/003/
- https://attack.mitre.org/techniques/T1543/002/
author: Security Arsenal
date: 2026/11/06
tags:
- attack.persistence
- attack.t1053.003
- attack.t1543.002
logsource:
category: file_event
product: linux
detection:
selection_paths:
TargetFilename|startswith:
- '/etc/cron.d/'
- '/etc/cron.daily/'
- '/etc/cron.hourly/'
- '/etc/systemd/system/'
- '/var/spool/cron/'
filter_package_managers:
Image|endswith:
- '/dpkg'
- '/apt'
- '/apt-get'
- '/rpm'
- '/yum'
- '/dnf'
- '/systemctl'
condition: selection_paths and not filter_package_managers
falsepositives:
- Configuration management tooling (Ansible, Puppet, Chef) writing unit files; filter by management node source or process name in your environment
level: high
KQL — Microsoft Sentinel (Linux Syslog / auditd ingestion)
This hunt targets MONAI Label exploitation artifacts via Syslog and auditd data forwarded to Sentinel. Adjust the datastore path filter to match your deployment.
// Hunt 1: Shells or download tools spawned under the MONAI/Uvicorn service context
Syslog
| where TimeGenerated > ago(14d)
| where ProcessName in ("python", "python3", "uvicorn") or SyslogMessage has_any ("monailabel", "monai_label", "uvicorn")
| where SyslogMessage has_any ("/bin/sh", "/bin/bash", "curl ", "wget ", "chmod +x", "authorized_keys")
| project TimeGenerated, Computer, ProcessName, ProcessID, SyslogMessage
| order by TimeGenerated desc;
// Hunt 2: auditd file-write telemetry — writes to persistence locations by Python processes
// (requires auditd rules watching /etc/cron.d, /etc/systemd/system, and .ssh directories)
LinuxAuditEvent
| where TimeGenerated > ago(14d)
| where RecordType in ("SYSCALL", "PATH")
| where ProcessName has "python" or exe has "python"
| where nametype == "CREATE" or syscall in ("openat", "creat", "rename")
| where path has_any ("/etc/cron", "/etc/systemd/system", "authorized_keys", "/var/spool/cron")
| summarize FirstSeen=min(TimeGenerated), LastSeen=max(TimeGenerated), Paths=make_set(path) by Computer, ProcessName, ppid
| order by FirstSeen asc;
// Hunt 3: Unauthenticated-looking burst of HTTP requests to MONAI Label API routes from single sources
// (requires reverse-proxy / WAF / firewall logs via CommonSecurityLog)
CommonSecurityLog
| where TimeGenerated > ago(14d)
| where RequestURL has_any ("/datastore/", "/activelearning/", "/train/", "/infer/", "/info/")
| summarize RequestCount=count(), DistinctPaths=dcount(RequestURL), Methods=make_set(RequestMethod) by SourceIP, DestinationHostName
| where RequestCount > 50 or (DistinctPaths > 5 and Methods has "PUT") or (DistinctPaths > 5 and Methods has "POST")
| order by RequestCount desc;
Velociraptor VQL — Endpoint Hunt
Use this artifact across suspected MONAI Label hosts to surface post-exploitation artifacts: shells under the service, recently modified persistence locations, and unexpected SSH keys.
-- MONAI Label post-exploitation hunt: process tree, persistence artifacts, SSH keys
-- Deploy across servers hosting MONAI Label; review results for anomalies.
-- 1) Processes with shells/download tools parented to Python or uvicorn
SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE Name =~ '(?i)(sh|bash|dash|curl|wget|nc|ncat)'
AND Ppid IN (
SELECT Pid FROM pslist()
WHERE CommandLine =~ '(?i)(monailabel|monai_label|uvicorn)'
)
-- 2) Recently created/modified cron and systemd persistence artifacts
SELECT FullPath, Size, Mtime, Ctime
FROM glob(globs=[
'/etc/cron.d/*',
'/etc/cron.daily/*',
'/etc/cron.hourly/*',
'/etc/systemd/system/*.service',
'/etc/systemd/system/*.timer',
'/var/spool/cron/*',
'/var/spool/cron/crontabs/*'
])
WHERE Mtime > (now() - 1209600) -- last 14 days
ORDER BY Mtime DESC
-- 3) SSH authorized_keys modified recently (potential key-drop persistence)
SELECT FullPath, Size, Mtime
FROM glob(globs=['/root/.ssh/authorized_keys', '/home/*/.ssh/authorized_keys'])
WHERE Mtime > (now() - 1209600)
ORDER BY Mtime DESC
Remediation & Verification Script (Bash)
Run on each host suspected of running MONAI Label. The script inventories the installation, checks the vulnerable version condition, flags common post-exploitation artifacts, and applies immediate hardening if an upgrade can't be completed in the same window.
#!/usr/bin/env bash
# MONAI Label <=0.8.5 unauthenticated file-write — verify & harden
# Run as root on each MONAI Label host. Review output before upgrading.
set -euo pipefail
echo "=== [1] Locate MONAI Label installation and version ==="
MONAI_VER=$(python3 -c "import monailabel; print(monailabel.__version__)" 2>/dev/null || pip3 show monailabel 2>/dev/null | awk '/^Version/{print $2}' || echo "NOT_FOUND")
echo "Installed monailabel version: ${MONAI_VER}"
if [ "${MONAI_VER}" != "NOT_FOUND" ]; then
if printf '%s\n0.8.5\n' "${MONAI_VER}" | sort -V -C; then
echo "[!] VULNERABLE: version <= 0.8.5 in default configuration. Treat as exposed."
else
echo "[+] Version is newer than 0.8.5 — still verify against the latest upstream release."
fi
fi
echo "=== [2] Identify the running service and its privilege level ==="
ps aux | grep -Ei 'monailabel|monai_label|uvicorn' | grep -v grep || echo "No live MONAI Label process found."
systemctl list-units --type=service 2>/dev/null | grep -Ei 'monai|uvicorn' || true
# If the service runs as root, it must be re-scoped — root execution is what turned a file write into full compromise.
SVCS=$(systemctl list-units --type=service --no-legend 2>/dev/null | grep -Ei 'monai|uvicorn' | awk '{print $1}' || true)
for s in $SVCS; do
echo "--- unit: $s"
systemctl cat "$s" | grep -Ei 'User=|Group=|ExecStart=' || true
done
echo "=== [3] Hunt common post-exploitation artifacts (last 14 days) ==="
echo "--- recently modified cron/systemd artifacts:"
find /etc/cron.d /etc/cron.daily /etc/cron.hourly /etc/systemd/system /var/spool/cron -type f -mtime -14 2>/dev/null | head -50
echo "--- recently modified authorized_keys:"
find /root/.ssh /home/*/.ssh -name authorized_keys -mtime -14 2>/dev/null
echo "--- files owned by the service user outside datastore (review manually):"
find /tmp /var/tmp /dev/shm -type f -mtime -14 2>/dev/null | head -50
echo "=== [4] Check network exposure ==="
ss -tlnp 2>/dev/null | grep -Ei 'python|uvicorn' || echo "No listening MONAI/Uvicorn sockets found."
echo "[!] If bound to 0.0.0.0, the instance is network-reachable — restrict immediately."
echo "=== [5] Interim hardening (if upgrade must be scheduled) ==="
cat <<'EOF'
Recommended immediate actions (apply manually or via config management):
1. UPGRADE: pip3 install --upgrade monailabel # verify version against the latest GitHub/PyPI release
2. BIND LOCAL: start with --host 127.0.0.1 and front with an authenticated reverse proxy
3. DROP PRIVILEGE: run the service as a dedicated non-root user with write access ONLY to the datastore
4. EGRESS DENY: block outbound internet from the MONAI host except approved update/model endpoints
5. ISOLATE: place the host in a segmented research/DMZ VLAN with no lateral path to PACS/EHR/AD
6. MONITOR: add auditd watches: -w /etc/cron.d -p wa and -w /etc/systemd/system -p wa
EOF
Remediation
Immediate (within 24–72 hours)
- Inventory every MONAI Label instance. This is the hardest step for most organizations — MONAI Label is frequently deployed ad hoc by research and data-science teams, inside Docker containers, on cloud VMs, or on lab workstations, entirely outside asset management. Query container registries, cloud inventories, EDR software inventories, and network scans for the MONAI Label service signature.
- Upgrade to the latest MONAI Label release. As of disclosure, versions 0.8.5 and earlier are affected in default configuration — pull the current release from the official Project-MONAI GitHub repository (
github.com/Project-MONAI/MONAILabel) or PyPI (pip install --upgrade monailabel) and confirm the installed version is newer than 0.8.5. Monitor the upstream repository for the formal security advisory and any assigned CVE. - Remove direct network exposure. If the instance cannot be patched immediately, take it off the network or bind it to localhost (
--host 127.0.0.1) behind an authenticated reverse proxy. An unauthenticated remote file write means any reachable instance is an open door. - Hunt before you patch. Patch-then-hunt destroys evidence. Run the VQL and auditd hunts above first; preserve disk images of any host showing the indicators (cron/systemd artifacts written by the service, new SSH keys, shells under the Python process). Root compromise was already achieved at one university — assume the same targeting across the research and academic medical sector.
Short-Term (1–2 weeks)
- Re-scope service privileges. Nothing about MONAI Label requires root. Run it as a dedicated unprivileged user with filesystem write access only to the datastore directory. For containerized deployments, run rootless, drop all capabilities, and never mount the host filesystem or Docker socket.
- Segment medical-imaging and research infrastructure. These servers hold PHI-adjacent data and frequently have trust relationships with PACS, research NAS, and cloud storage. Place them in a dedicated segment with explicit deny rules toward EHR, clinical systems, and directory services.
- Egress control. Research servers should not have unrestricted outbound internet. Allowlist package repositories, model registries, and approved cloud endpoints; alert on everything else. Most post-exploitation tooling needs egress.
- Enable syscall-level auditing on all MONAI hosts: auditd watches on
/etc/cron.d,/etc/systemd/system, and*/.ssh/authorized_keys, plus process execution logging (the detections above depend on it).
Strategic (this quarter)
- Close the shadow-AI/research-tooling gap. The exploited server was at a university. The common thread in these environments is ungoverned deployment of open-source AI tooling. Bring research compute under vulnerability management scope — you cannot patch what you don't inventory.
- Recalibrate threat models for AI-agent-accelerated adversaries. Assume every exposed open-source service in your estate is being continuously, autonomously probed for novel vulnerabilities. Shrink attack surface (default-deny exposure), shrink patch latency, and shrink blast radius (segmentation, least privilege). These three controls are the durable answer to automated zero-day discovery.
- Monitor upstream. Subscribe to releases and security advisories for Project-MONAI, and track Amazon Threat Intelligence's reporting for the formal CVE assignment and any expanded IOC set. If your organization is HIPAA-regulated and MONAI hosts touch PHI, evaluate breach-notification obligations for any instance found exposed during your inventory sweep.
Related Resources
Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub
Is your security operations ready?
Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.