AWS’s “Found a Zero-Day on Their Own” Post Never Names the Product; the Advisory Behind Its Link Shows a Server That Ships With No Login, a README Now Saying Keep It Off the Internet, and a Fix Merged October 19 That PyPI and Docker Hub Still Do Not Carry
AWS says Cairn’s agents found a zero-day on their own, but its text names no product, the server behind the advisory link ships with login off, and the fix merged on October 19 is in no PyPI or...
Amazon’s November 20 report says a “Chinese-nexus” operator pointed an open-source tool called Cairn at university servers, and that the AI agents it coordinated “found a zero-day in an open-source application and used it to gain full control of a server.” The headline is blunter: the agents “found a zero-day on their own.” The text never says which application. The link labelled “GitHub Security Advisory” does: it points at MONAI Label, a server for AI-assisted labeling of medical images.
Table Of Content
- The short version
- What the AWS post says
- The campaign
- The three operations
- The hand-off, the attribution and the response
- The product is in a link, not in the text
- The timeline, counted from the day AWS found the server
- “They released a fix”: what a user can actually install
- Where the records diverge
- Why a file write was enough
- Hop 1: open by default
- Hop 2: the upload writes where the caller says
- Hop 3: the server starts Python with its own folder on the path
- Testing which folders run a planted file
- What the fix changes, and what it leaves alone
- Does “on their own” survive the records?
- What I would do now
- What I could not check
- Sources
I read that advisory, the pull request that fixes it, the 0.8.5 wheel that PyPI still serves, the Docker Hub tags, the CVE record MITRE published an hour after AWS’s post, and The Register’s coverage, then ran four small scripts. The agents’ persistence is real news. What the records add is a server that ships with login switched off, whose maintainers wrote on November 19 that it should not face the internet, and whose fix, merged on October 19, is in no published release.
The short version
- AWS’s text calls the target “an open-source medical imaging AI application” and never names it. The advisory behind the link names MONAI Label.
- In version 0.8.5 the login setting defaults to off and the server listens on all interfaces. A file write there becomes code execution through the server’s own PYTHONPATH and its training launcher; the lab below shows which folders make that work.
- Counted from the day AWS found the Cairn server, the fix pull request opened on day 32, merged on day 39, and the advisory went up on day 69. AWS does not say when it reported the flaw.
- AWS says the maintainers “released a fix.” The fix is on the main branch. PyPI’s newest version is 0.8.5 from November 25, 2024, which the advisory lists as vulnerable, and Docker Hub’s newest tag was pushed on June 8, 2025.
- Between the headline and the text there are gaps: “on their own” sits beside an operator who wrote the prompts, supplied the targets and later handed over a proxy, and a “hardened” Redis server is described as “configured to allow access without authentication.”
What the AWS post says
The campaign
On September 10, 2026, Amazon Threat Intelligence “identified a server with a publicly hosted instance of Cairn, an open-source autonomous AI penetration-testing framework, running without authentication.” Because the operator left it open, the platform’s history was visible: project configurations, prompts and model output. The prompts were in Simplified Chinese and script timestamps used China Standard Time. The campaign targeted “IP addresses associated with universities in East Asia outside mainland China over an approximately 48-hour period beginning September 8, 2026.” Our October 19 report found the same property in Cairn’s own repository: no login on the server.
The three operations
- A Redis server. “Over roughly 16 hours and 148 sequential actions” the agents tried replication abuse, a scripting-sandbox escape, configuration writes and memory corruption, plus Log4Shell against another service on the same system, then mapped a Docker network through a Qdrant request-forgery flaw and sprayed credentials. “None of these attempts succeeded.”
- A GPU server. More than six hours, a list of “about 80 real usernames” and “more than 30,000 credential combinations.” “They never found a working login.”
- A medical imaging application. The agents “found an upload endpoint with a filename parameter,” tested it for path traversal, and “in about 11 minutes” went from mapping the API to “arbitrarily writing files on the server.” In a later session they wrote a reverse shell to
sitecustomize.py, “triggered a training API endpoint to spawn a new Python process,” and got a shell “running as root.”
The hand-off, the attribution and the response
“In another session, the threat actor stepped in” and gave the agents a proxy into a second university network that was “running the same vulnerable software.” AWS says it assesses “with moderate confidence” that the actor is Chinese-nexus, based on the prompt language, the timestamps and the choice of targets. It says it notified the maintainers and that “they released a fix and a GitHub Security Advisory,” and that it worked with a government partner to notify the affected organizations, which were not AWS customers. The only indicators are two IPv4 addresses.
The product is in a link, not in the text
The visible words are “an open-source application” and “an open-source medical imaging AI application.” The advisory link goes to Project-MONAI/MONAILabel. The Register names “MONAI Label” in its text. The advisory, GHSA-qc22-rmgc-vg94, was published on November 18 at 15:45 UTC, two days before the AWS post. These are its fields as GitHub’s API returns them:
- Title: “Path traversal in datastore upload endpoints allows arbitrary file write.” Severity: critical, with no CVSS score filled in. Weakness: CWE-22.
- Package
monailabelon PyPI, vulnerable range<= 0.8.5, patched versions blank. The text says “The fix will be included in the next MONAI Label release.” - The description begins “Originally reported by @aws-sec-vdp” against a different advisory in the core MONAI repository, which does not resolve for an anonymous visitor, and says this one was “re-reported to generate CVE in the correct repository.” The credited reporter on this advisory is a different account.
- “Authentication is disabled by default (
MONAI_LABEL_AUTH_ENABLE=False), so in the default configuration any network client that can reach the server can exploit this. With authentication enabled, theANNOTATORrole is sufficient.”
The timeline, counted from the day AWS found the server
The script below holds the dates I read from the sources and prints the gaps. The campaign start and the discovery date are dates only, so the first two rows carry up to a day of rounding.
# gaps.py - day counts between the dated events in the AWS post, the GitHub records and the package indexes,
# plus the arithmetic on the numbers the AWS post prints. Dates come from the sources named in the article.
from datetime import datetime, timezone
def d(s):
return datetime.fromisoformat(s).replace(tzinfo=timezone.utc)
EVENTS = [
("campaign begins (AWS post)", d("2026-09-08T00:00:00")),
("AWS finds the Cairn server (AWS post)", d("2026-09-10T00:00:00")),
("fix PR 1915 opened", d("2026-10-12T13:46:05")),
("fix PR 1915 merged to main", d("2026-10-19T13:37:36")),
("README warning PR 1940 opened", d("2026-11-18T15:26:11")),
("GitHub advisory published", d("2026-11-18T15:45:41")),
("README warning PR 1940 merged", d("2026-11-19T08:51:42")),
("AWS post and The Register story", d("2026-11-20T17:30:13")),
("CVE-2026-133968 published (MITRE)", d("2026-11-20T18:31:38")),
]
PYPI_LATEST = d("2024-11-25T23:22:11") # monailabel 0.8.5 upload
DOCKER_LATEST = d("2025-06-08T02:59:49") # projectmonai/monailabel:latest push
CHECK = d("2026-11-21T19:42:00") # when the release lists were last read for this article
def days(a, b):
return (b - a).total_seconds() / 86400
def main():
base = EVENTS[1][1]
print("%-40s %-20s %s" % ("event", "UTC", "days after AWS finds the server"))
for name, t in EVENTS:
print("%-40s %-20s %5.1f" % (name, t.strftime("%Y-%m-%d %H:%M"), days(base, t)))
print()
print("fix merged -> advisory published: %.1f days" % days(EVENTS[3][1], EVENTS[5][1]))
print("fix merged -> release lists read: %.1f days (no release in between)" % days(EVENTS[3][1], CHECK))
print("README warning opened -> advisory published: %.0f minutes" % (days(EVENTS[4][1], EVENTS[5][1]) * 1440))
print("AWS post -> CVE published: %.0f minutes" % (days(EVENTS[7][1], EVENTS[8][1]) * 1440))
print("last PyPI release (0.8.5) -> fix merged: %.1f days" % days(PYPI_LATEST, EVENTS[3][1]))
print("last PyPI release (0.8.5) -> release lists read: %.1f days" % days(PYPI_LATEST, CHECK))
print("last Docker latest push -> release lists read: %.1f days" % days(DOCKER_LATEST, CHECK))
print()
print("numbers printed in the AWS post")
print(" Redis operation: 16 h / 148 actions = %.1f minutes per action" % (16 * 60 / 148))
print(" GPU server: 30,000 combinations / about 80 usernames = %.0f per username" % (30000 / 80))
print(" GPU server: 30,000 combinations in 6 h = %.0f per minute (if spread over the whole run)" % (30000 / (6 * 60)))
print(" zero-day: about 11 minutes inside a campaign of about 48 hours = %.2f percent of the window" % (11 / (48 * 60) * 100))
if __name__ == "__main__":
main()
event UTC days after AWS finds the server
campaign begins (AWS post) 2026-09-08 00:00 -2.0
AWS finds the Cairn server (AWS post) 2026-09-10 00:00 0.0
fix PR 1915 opened 2026-10-12 13:46 32.6
fix PR 1915 merged to main 2026-10-19 13:37 39.6
README warning PR 1940 opened 2026-11-18 15:26 69.6
GitHub advisory published 2026-11-18 15:45 69.7
README warning PR 1940 merged 2026-11-19 08:51 70.4
AWS post and The Register story 2026-11-20 17:30 71.7
CVE-2026-133968 published (MITRE) 2026-11-20 18:31 71.8
fix merged -> advisory published: 30.1 days
fix merged -> release lists read: 33.3 days (no release in between)
README warning opened -> advisory published: 20 minutes
AWS post -> CVE published: 61 minutes
last PyPI release (0.8.5) -> fix merged: 692.6 days
last PyPI release (0.8.5) -> release lists read: 725.8 days
last Docker latest push -> release lists read: 531.7 days
numbers printed in the AWS post
Redis operation: 16 h / 148 actions = 6.5 minutes per action
GPU server: 30,000 combinations / about 80 usernames = 375 per username
GPU server: 30,000 combinations in 6 h = 83 per minute (if spread over the whole run)
zero-day: about 11 minutes inside a campaign of about 48 hours = 0.38 percent of the window
Three readings follow. First, the post’s statement that the flaw “did not correspond to any assigned security advisory and was unpatched” at discovery holds: the first fix pull request is dated October 12. Second, AWS gives no report date, and the advisory credits its account without one, so the 32 days to a pull request is a ceiling on the project’s response time, not a measurement of it. Third, the advisory appeared about 20 minutes after a second pull request, a README warning, was opened, and the CVE appeared an hour after AWS’s post. The next section covers both.
“They released a fix”: what a user can actually install
The fix is pull request 1915, “fix: confine datastore write paths,” opened on October 12 and merged by a maintainer on October 19. It touches 11 files (133 lines added, 10 removed), and also repairs failing CI and works around a MONAI 1.6 regression, so it is a development snapshot rather than a patch release. This script reads the release lists and the advisory directly, with no token (GitHub allows 60 anonymous requests an hour):
# release_check.py - read-only status check: is there a MONAI Label release that carries the fix?
# Stdlib only. Makes about eight GET requests (GitHub allows 60 per hour without a token).
import json
import urllib.request
from datetime import datetime, timezone
UA = "release-status-check/1.0 (read-only)"
GH = "https://api.github.com/repos/Project-MONAI/MONAILabel"
def get(url, accept="application/json"):
req = urllib.request.Request(url, headers={"User-Agent": UA, "Accept": accept})
with urllib.request.urlopen(req, timeout=40) as resp:
return json.load(resp)
def days_since(iso):
t = datetime.fromisoformat(iso.replace("Z", "+00:00"))
return (datetime.now(timezone.utc) - t).days
def main():
print("checked (UTC):", datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M"))
pypi = get("https://pypi.org/pypi/monailabel/json")
latest = pypi["info"]["version"]
up = min(f["upload_time_iso_8601"] for f in pypi["releases"][latest])
print("PyPI latest: %s uploaded %s (%d days ago)" % (latest, up[:10], days_since(up)))
print("PyPI page text mentions 'internet-facing':", "internet-facing" in (pypi["info"].get("description") or ""))
tags = get("https://hub.docker.com/v2/repositories/projectmonai/monailabel/tags?page_size=3&ordering=last_updated")
for t in tags["results"]:
print("Docker Hub tag %-7s pushed %s" % (t["name"], t["tag_last_pushed"][:10]))
adv = [a for a in get(GH + "/security-advisories?per_page=20") if a["ghsa_id"] == "GHSA-qc22-rmgc-vg94"][0]
vuln = adv["vulnerabilities"][0]
print("advisory %s published %s severity %s cve_id %s" % (adv["ghsa_id"], adv["published_at"][:10], adv["severity"], adv["cve_id"]))
print("advisory vulnerable range %r, patched versions %r" % (vuln["vulnerable_version_range"], vuln["patched_versions"]))
pr = get(GH + "/pulls/1915")
print("fix PR 1915 merged %s (commit %s)" % (pr["merged_at"][:10], pr["merge_commit_sha"][:9]))
cmp_ = get(GH + "/compare/0.8.5..." + pr["merge_commit_sha"])
print("fix commit is %d commits ahead of the 0.8.5 tag" % cmp_["ahead_by"])
cve = get("https://cveawg.mitre.org/api/cve/CVE-2026-133968")
meta = cve["cveMetadata"]
cna = cve["containers"]["cna"]
print("CVE record %s state %s published %s assigner %s" % (meta["cveId"], meta["state"], meta["datePublished"][:10], meta["assignerShortName"]))
print("CVE affected versions:", cna["affected"][0]["versions"][0])
ssvc = [a for a in cve["containers"].get("adp", []) if a["providerMetadata"]["shortName"] == "CISA-ADP"]
if ssvc:
opts = ssvc[0]["metrics"][0]["other"]["content"]["options"]
print("CISA-ADP SSVC:", {k: v for o in opts for k, v in o.items()})
if __name__ == "__main__":
main()
Output as of 19:42 UTC on November 21:
checked (UTC): 2026-11-21 19:42
PyPI latest: 0.8.5 uploaded 2024-11-25 (725 days ago)
PyPI page text mentions 'internet-facing': False
Docker Hub tag latest pushed 2025-06-08
Docker Hub tag 0.8.5 pushed 2024-11-25
Docker Hub tag 0.8.0 pushed 2023-10-19
advisory GHSA-qc22-rmgc-vg94 published 2026-11-18 severity critical cve_id None
advisory vulnerable range '<= 0.8.5', patched versions ''
fix PR 1915 merged 2026-10-19 (commit 113527bf6)
fix commit is 32 commits ahead of the 0.8.5 tag
CVE record CVE-2026-133968 state PUBLISHED published 2026-11-20 assigner mitre
CVE affected versions: {'lessThanOrEqual': '0.8.5', 'status': 'affected', 'version': '0', 'versionType': 'semver'}
CISA-ADP SSVC: {'Exploitation': 'none', 'Automatable': 'yes', 'Technical Impact': 'total'}
So the fix commit is 32 commits past the 0.8.5 tag, and neither a package index nor a container tag carries it. A user who runs pip install monailabel gets the code in the advisory’s vulnerable range. I downloaded that wheel, confirmed its SHA-256 against PyPI’s digest, and read the upload path in it: the pre-fix lines are there. “Released a fix” is true of the source tree. It is not true of anything a deployment script would pull.
Where the records diverge
- The README. Pull request 1940, opened November 18 at 15:26 UTC and merged the next morning, adds a warning to the main branch README: “MONAI Label is not intended to be run as an internet-facing application,” citing “a number of known, unpatched security issues,” and tells readers to deploy only on “a closed, trusted local area network (LAN).” It is not in the README that PyPI shows for 0.8.5, and AWS’s post does not mention it.
- The CVE. CVE-2026-133968 was assigned by MITRE, not by the project, and published on November 20 at 18:31 UTC. Its text says the flaw was “exploited in the wild starting in September 2026,” its references include The Register’s story, its vendor field reads “Project-MONIA,” and NVD shows it as “Received” with a 9.8 base score from MITRE (weakness CWE-24, where the advisory says CWE-22). The GitHub advisory still showed no CVE ID at 19:42 UTC.
- The exploitation field. CISA’s coordinator entry on the same record, stamped 21:34 UTC the same day, reads Exploitation “none,” Automatable “yes,” Technical Impact “total.” The CVE text and that entry were written about three hours apart and disagree about whether exploitation has happened.
Why a file write was enough
AWS describes a write primitive and then a shell. Reading the 0.8.5 wheel shows why the two are close together in this product. I cite line numbers from that wheel, and I read the code without starting a server.
Hop 1: open by default
monailabel/config.py line 31 sets MONAI_LABEL_AUTH_ENABLE: bool = False. main.py lines 54 and 55 default the server to host 0.0.0.0 and port 8000. app.py lines 82 and 83 mount the login router only when authentication is enabled, so a default install has no /auth/ route at all (I read this; I did not start a server). Line 59 publishes the API description at /openapi.json, which is the “mapping the application’s API” step handed to anyone who asks.
Hop 2: the upload writes where the caller says
Both PUT /datastore/image and a deprecated, schema-hidden PUT /datastore/ call the same function. It takes the query parameter image as the image ID with no checks. In datastore/local.py, add_image builds name = id + extension (line 440), resolves os.path.realpath(os.path.join(image_path, name)) (line 441) and copies the upload there with shutil.copy (line 445). The extension comes from the uploaded file’s own name, so a caller controls both the folder and the suffix. AWS’s “filename parameter” is presumably this ID.
Hop 3: the server starts Python with its own folder on the path
When the server starts, main.py line 314 appends the application folder (the --app argument) to PYTHONPATH. A training request then runs utils.py lines 55 to 67: subprocess.Popen([sys.executable, "-m", "monailabel.interfaces.utils.app", "-m", method, "-r", ...], env=my_env), where the environment is a copy of the server’s. The new interpreter is started with no -I, -E or -S. AWS does not say which folder received sitecustomize.py; this is one route, and the app folder is one the service account must be able to write to, since the server creates its subfolders there at start (lines 307 to 311).
Testing which folders run a planted file
Python imports sitecustomize while it initializes, before the script folder is added to the path, so the answer depends on what is on the path at that moment. This script copies the server’s launch pattern (a PYTHONPATH folder, then python -m pkg.child from a working folder) and plants one harmless marker-writing file at a time. The planted files only append a label to a marker file. The last step is a defender’s view: the folders the interpreter searches, listing files that can run code.
# hook_matrix.py - which directories make a NEW Python process run a planted startup file?
# It models the MONAI Label training launch: the server puts its app folder on PYTHONPATH
# (monailabel/main.py) and then starts sys.executable -m monailabel.interfaces.utils.app
# (monailabel/utils/async_tasks/utils.py) with the inherited environment.
# The planted files only append a label to a marker file. Nothing else runs.
import json
import os
import pathlib
import shutil
import subprocess
import sys
import tempfile
import venv
FLAGS = [("default", []), ("-I", ["-I"]), ("-E", ["-E"]), ("-S", ["-S"])]
def plant(kind, folder, label):
folder = pathlib.Path(folder)
folder.mkdir(parents=True, exist_ok=True)
if kind == "sitecustomize":
(folder / "sitecustomize.py").write_text(
'import os\nopen(os.environ["HOOK_MARKER"], "a").write("%s" + chr(10))\n' % label, encoding="utf-8")
else: # a .pth file with an import line
(folder / "hook.pth").write_text(
"import os; open(os.environ['HOOK_MARKER'], 'a').write('%s' + chr(10))\n" % label, encoding="utf-8")
def unplant(folder):
for name in ("sitecustomize.py", "hook.pth"):
p = pathlib.Path(folder) / name
if p.exists():
p.unlink()
def find_hooks(python, env):
"""Defender view: files in the folders this interpreter searches at start-up that can run code."""
out = subprocess.run([python, "-c", "import sys, json; print(json.dumps(sys.path))"],
env=env, capture_output=True, text=True).stdout
found = []
for p in json.loads(out):
d = pathlib.Path(p or ".")
if not d.is_dir():
continue
for name in ("sitecustomize.py", "usercustomize.py"):
if (d / name).is_file():
found.append(str(d / name))
for f in d.glob("*.pth"):
if any(line.startswith("import") for line in f.read_text(errors="replace").splitlines()):
found.append(str(f))
return found
def main():
work = pathlib.Path(tempfile.mkdtemp(prefix="hookmx_")).resolve()
try:
run_dir, app_dir = work / "run", work / "app"
(run_dir / "pkg").mkdir(parents=True)
app_dir.mkdir()
(run_dir / "pkg" / "__init__.py").write_text("", encoding="utf-8")
(run_dir / "pkg" / "child.py").write_text("print('child ran')\n", encoding="utf-8")
venv.create(work / "venv", with_pip=False)
vpy = str(work / "venv" / ("Scripts/python.exe" if os.name == "nt" else "bin/python"))
site_pkgs = subprocess.check_output(
[vpy, "-c", "import sysconfig; print(sysconfig.get_paths()['purelib'])"], text=True).strip()
print("python:", subprocess.check_output([vpy, "-V"], text=True).strip(), "| os:", os.name)
cases = [
("sitecustomize.py in the app folder (on PYTHONPATH)", "sitecustomize", app_dir),
(".pth file in the app folder (on PYTHONPATH)", "pth", app_dir),
("sitecustomize.py in the working folder only", "sitecustomize", run_dir),
("sitecustomize.py inside the package folder", "sitecustomize", run_dir / "pkg"),
("sitecustomize.py in site-packages", "sitecustomize", pathlib.Path(site_pkgs)),
(".pth file in site-packages", "pth", pathlib.Path(site_pkgs)),
]
print("%-52s | %-7s | %-3s | %-3s | %-3s" % ("planted file", "default", "-I", "-E", "-S"))
for text, kind, folder in cases:
cells = []
for _, flags in FLAGS:
marker = work / "marker.txt"
if marker.exists():
marker.unlink()
plant(kind, folder, "ran")
env = {**os.environ, "HOOK_MARKER": str(marker), "PYTHONPATH": str(app_dir)}
subprocess.run([vpy, *flags, "-m", "pkg.child"], cwd=run_dir, env=env, capture_output=True, text=True)
cells.append("RAN" if marker.exists() else "-")
unplant(folder)
print("%-52s | %-7s | %-3s | %-3s | %-3s" % (text, *cells))
# defender view on the same layout: what would an audit of the service's environment list?
plant("sitecustomize", app_dir, "ran")
plant("pth", pathlib.Path(site_pkgs), "ran")
env = {**os.environ, "PYTHONPATH": str(app_dir)}
print("audit of the service environment finds:")
for f in find_hooks(vpy, env):
print(" ", pathlib.Path(f).relative_to(work).as_posix())
finally:
shutil.rmtree(work, ignore_errors=True)
if __name__ == "__main__":
main()
python: Python 3.13.14 | os: nt
planted file | default | -I | -E | -S
sitecustomize.py in the app folder (on PYTHONPATH) | RAN | - | - | -
.pth file in the app folder (on PYTHONPATH) | - | - | - | -
sitecustomize.py in the working folder only | - | - | - | -
sitecustomize.py inside the package folder | - | - | - | -
sitecustomize.py in site-packages | RAN | RAN | RAN | -
.pth file in site-packages | RAN | RAN | RAN | -
audit of the service environment finds:
app/sitecustomize.py
venv/Lib/site-packages/hook.pth
Four findings. A sitecustomize.py in a PYTHONPATH folder runs, and the server puts its app folder there. The same file in the working folder or the package folder does not run. -I and -E switch off the PYTHONPATH route but not site-packages, and -S switches off both. And a .pth file does nothing in a PYTHONPATH folder, which is worth knowing because a hunt built around .pth files, like the one in our agent-framework report, would not see a planted sitecustomize.py. I ran this on Python 3.13.14 on Windows 11; I did not start MONAI Label, and the model child is pkg.child, not the real module.
What the fix changes, and what it leaves alone
The pull request adds LocalDatastore._confine_path, which resolves a destination with realpath and refuses it unless commonpath shows it inside the allowed folder, and calls it in add_image and, for both the label folder and the final file, in save_label. The endpoint now reduces a supplied image ID to its basename and answers HTTP 400 for an empty, ., .. or dot-prefixed ID. It also adds unit tests for these cases. The script below copies the two pieces from the diff and the old path arithmetic from 0.8.5, then runs hostile values under POSIX and Windows path rules. It models path strings only: no server runs and no datastore is written. The last block uses real symlinks in a temporary folder.
# fix_matrix.py - path arithmetic for MONAI Label datastore writes, before and after PR 1915.
# It models ONLY the string and path math. No server runs and nothing is written to the datastore.
#
# before = what monailabel 0.8.5 does in LocalDatastore.add_image / save_label:
# dest = os.path.realpath(os.path.join(image_dir, id + ext))
# after = the PR 1915 endpoint normalisation plus LocalDatastore._confine_path (Apache-2.0, copied
# from the diff and parameterised so it can run with Windows or POSIX path rules).
import ntpath
import os
import posixpath
import shutil
import tempfile
def make_env(mod, real, img, lab):
return {"mod": mod, "real": real, "img": img, "lab": lab}
POSIX = make_env(posixpath, posixpath.normpath, "/srv/monai/datastore/images", "/srv/monai/datastore/labels")
NT = make_env(ntpath, ntpath.realpath, "C:\\monai\\datastore\\images", "C:\\monai\\datastore\\labels")
def inside(env, dest, base):
try:
return env["mod"].commonpath([dest, base]) == base
except ValueError: # e.g. different drives on Windows
return False
def confine_path(env, dest, allowed_base): # PR 1915: LocalDatastore._confine_path
dest = env["real"](dest)
allowed_base = env["real"](allowed_base)
if not inside(env, dest, allowed_base):
raise ValueError("refused")
return dest
def endpoint_normalise(env, image_id): # PR 1915: monailabel/endpoints/datastore.py
image_id = env["mod"].basename(image_id)
if not image_id or image_id in (".", "..") or image_id.startswith("."):
raise KeyError("HTTP 400")
return image_id
def before_image(env, image_id, ext):
dest = env["real"](env["mod"].join(env["img"], image_id + ext))
return "inside" if inside(env, dest, env["real"](env["img"])) else "OUTSIDE " + dest
def after_image(env, image_id, ext):
try:
image_id = endpoint_normalise(env, image_id)
except KeyError:
return "400"
try:
dest = confine_path(env, env["mod"].join(env["img"], image_id + ext), env["img"])
except ValueError:
return "refused"
return "stored as " + env["mod"].basename(dest)
def before_label(env, tag, ext):
m = env["mod"]
label_dir = m.join(env["lab"], tag) if tag else env["lab"]
dest = env["real"](m.join(label_dir, "case001" + ext))
return "inside" if inside(env, dest, env["real"](env["lab"])) else "OUTSIDE " + dest
def after_label(env, tag, ext):
m = env["mod"]
label_dir = m.join(env["lab"], tag) if tag else env["lab"]
try:
label_dir = confine_path(env, label_dir, env["lab"])
dest = confine_path(env, m.join(label_dir, "case001" + ext), label_dir)
except ValueError:
return "refused"
return "stored in " + m.basename(label_dir)
IMAGE_IDS = [
"case001",
"sub/case001",
"../case001",
"../../../tmp/x",
"/etc/cron.d/x",
"C:/Windows/Temp/x",
"..\\..\\x",
"a/../../b",
".hidden",
"..",
"%2e%2e%2fx",
]
TAGS = ["final", "original", "../final2", "../../x", "/abs/dir", "..\\..\\x"]
def short(s, n=34):
return s if len(s) <= n else s[: n - 3] + "..."
def table(title, rows, fn_before, fn_after, ext):
print("== " + title + " (uploaded file suffix " + ext + ")")
print("%-20s | %-34s | %-22s | %-34s | %-22s" % ("value", "POSIX before", "POSIX after", "Windows before", "Windows after"))
for v in rows:
print("%-20s | %-34s | %-22s | %-34s | %-22s" % (
repr(v), short(fn_before(POSIX, v, ext)), fn_after(POSIX, v, ext),
short(fn_before(NT, v, ext)), fn_after(NT, v, ext)))
def symlink_check():
base = tempfile.mkdtemp(prefix="fixmx_")
try:
images = os.path.join(base, "datastore", "images")
labels = os.path.join(base, "datastore", "labels")
outside = os.path.join(base, "outside")
for d in (images, labels, os.path.join(labels, "final"), outside):
os.makedirs(d)
env = make_env(os.path, os.path.realpath, images, labels)
try:
os.symlink(outside, os.path.join(labels, "linkdir"), target_is_directory=True)
os.symlink(outside, os.path.join(images, "link"), target_is_directory=True)
except OSError as exc:
print("symlink test skipped:", exc)
return
print("== real symlinks in a temp datastore (this machine's rules)")
for tag in ("final", "linkdir"):
print("label tag %-8s -> %s" % (tag, after_label(env, tag, ".nii.gz")))
for ident in ("case001", "link/case001"):
ok = "stored" if inside(env, env["real"](os.path.join(images, ident + ".nii.gz")), env["real"](images)) else "refused"
print("confine only, id %-13s -> %s (the endpoint would already cut it to its basename)" % (ident, ok))
finally:
shutil.rmtree(base, ignore_errors=True)
if __name__ == "__main__":
table("image ID, PUT /datastore/image", IMAGE_IDS, before_image, after_image, ".py")
print()
table("label tag, PUT /datastore/label", TAGS, before_label, after_label, ".nii.gz")
print()
symlink_check()
== image ID, PUT /datastore/image (uploaded file suffix .py)
value | POSIX before | POSIX after | Windows before | Windows after
'case001' | inside | stored as case001.py | inside | stored as case001.py
'sub/case001' | inside | stored as case001.py | inside | stored as case001.py
'../case001' | OUTSIDE /srv/monai/datastore/ca... | stored as case001.py | OUTSIDE C:\monai\datastore\case... | stored as case001.py
'../../../tmp/x' | OUTSIDE /srv/tmp/x.py | stored as x.py | OUTSIDE C:\tmp\x.py | stored as x.py
'/etc/cron.d/x' | OUTSIDE /etc/cron.d/x.py | stored as x.py | OUTSIDE C:\etc\cron.d\x.py | stored as x.py
'C:/Windows/Temp/x' | inside | stored as x.py | OUTSIDE C:\Windows\Temp\x.py | stored as x.py
'..\\..\\x' | inside | 400 | OUTSIDE C:\monai\x.py | stored as x.py
'a/../../b' | OUTSIDE /srv/monai/datastore/b.py | stored as b.py | OUTSIDE C:\monai\datastore\b.py | stored as b.py
'.hidden' | inside | 400 | inside | 400
'..' | inside | 400 | inside | 400
'%2e%2e%2fx' | inside | stored as %2e%2e%2fx.py | inside | stored as %2e%2e%2fx.py
== label tag, PUT /datastore/label (uploaded file suffix .nii.gz)
value | POSIX before | POSIX after | Windows before | Windows after
'final' | inside | stored in final | inside | stored in final
'original' | inside | stored in original | inside | stored in original
'../final2' | OUTSIDE /srv/monai/datastore/fi... | refused | OUTSIDE C:\monai\datastore\fina... | refused
'../../x' | OUTSIDE /srv/monai/x/case001.ni... | refused | OUTSIDE C:\monai\x\case001.nii.gz | refused
'/abs/dir' | OUTSIDE /abs/dir/case001.nii.gz | refused | OUTSIDE C:\abs\dir\case001.nii.gz | refused
'..\\..\\x' | inside | stored in ..\..\x | OUTSIDE C:\monai\x\case001.nii.gz | refused
== real symlinks in a temp datastore (this machine's rules)
label tag final -> stored in final
label tag linkdir -> refused
confine only, id case001 -> stored (the endpoint would already cut it to its basename)
confine only, id link/case001 -> refused (the endpoint would already cut it to its basename)
What the table shows:
- Every image ID that escaped before is flattened to a plain file name after. The endpoint’s basename step does that work. The confinement check matters most for label tags, where it refuses rather than rewrites.
- Dot-prefixed IDs now get a 400, including legitimate hidden names. On POSIX the string
..\..\xis refused only because it starts with a dot; on Windows the same string is cut tox. - A symlinked label folder is refused on this machine’s real filesystem, because
realpathresolves the link before the containment test. - The patch does not touch the other hops: none of its 11 files changes the login default in
config.py, and its two-line edit tomain.pyconcerns a dataset download, not the bind address or thePYTHONPATHline. The advisory’s own workaround list says as much: enable authentication, keep it off untrusted networks, and run it unprivileged with write access limited to the datastore folder. Its impact section adds that with authentication on, the annotator role is enough.
The same lesson, confining every write to one folder after resolving it, is the core of our tutorials on secure file uploads in FastAPI and the agent file sandbox.
Does “on their own” survive the records?
The speed and the stamina in AWS’s account are credible, and nothing here disputes that agents ran for hours. The question is what the headline’s wording carries beyond that.
| Claim | What the post’s own text shows | What the other records add |
|---|---|---|
| “found a zero-day on their own” (AWS); “autonomously found and exploited a 0-day” (The Register headline) | The actor chose the targets, wrote the prompts and set the goal “obtain shell access.” The post’s summary says “minimal human involvement,” and the actor later “stepped in.” | The target publishes its API description without login and takes a caller-chosen ID straight into a file path. In my reading the bug class is a standard first test for an upload parameter; what is new is the speed and the thin human role, not an exotic flaw. |
| “Persistence against a hardened target” | The same section says the Redis server was “configured to allow access without authentication.” | The post does not say what stopped 148 actions, so “hardened” is a label without a described control. |
| “zero-day” | Basis: “the absence of any corresponding fix, issue, advisory, or prior mention in vulnerability databases.” | Consistent with the dates: the first fix pull request is October 12. AWS had reported it itself. For a defender the sharper fact is that no release fixes it. |
| “they released a fix” | No version is named. | The fix is on main since October 19. Newest PyPI version: 0.8.5, listed as vulnerable. |
| “moderate confidence” attribution | Three signals: Simplified Chinese prompts, China Standard Time timestamps, universities “likely of strategic interest to China.” | All three come from the operator’s own choices and configuration, and the post lists no infrastructure or tooling overlap with a known actor. The Register’s headline says “China attackers”; its text says “Suspected Chinese spies.” |
| Where the time went | About 16 hours and 6 hours on two targets that held, about 11 minutes on the one that fell. | 11 minutes is 0.38 percent of a 48-hour window (script above). The Redis server had no login and still held, so a missing login alone is not the whole story. The weak point here was a write primitive with a code-execution path built into the product’s design. |
| Indicators | Two addresses, “in records dated September 8 to 10, 2026.” | ARIN lists them as 2012 assignments to registrants named “hainet” and “Anxin.” Registration age says nothing about who used them in 2026, and a ten-week-old address is a weak block-list entry. |
The Register also says Cairn is used “to carry out multi-stage intrusions with no human assistance,” and puts the Redis attempts “before” the zero-day. The AWS text says “minimal” human involvement and lists the operations without an order. Those are the outlet’s glosses, not the report’s.
What I would do now
These steps are mine, not the project’s or AWS’s, and I did not test them against a running MONAI Label server.
- Find your servers.
pip show monailabelon each host and a look for theprojectmonai/monailabelcontainer image. Any version up to 0.8.5 is in the advisory’s range, and 0.8.5 is the newest published one. - Take it off the internet. The README now says to use a closed, trusted LAN and not to put a proxy in front for the public. In 0.8.5 the default bind address is
0.0.0.0; pass--host 127.0.0.1or firewall port 8000. - Turn on login, and do not stop there.
MONAI_LABEL_AUTH_ENABLE=Trueexpects a Keycloak-style identity provider (the default realm address inconfig.pypoints at one), and the advisory says the annotator role is still enough to exploit the flaw. - Cut the write path to code. Run the service as an unprivileged account. Because the app folder is on
PYTHONPATH, plantingsitecustomize.pythere needs write access to the app folder’s top level; the server createsmodel,lib,logsandbinunder it (main.pylines 307 to 311). Whether a read-only top level works with your setup is something to test first. - Audit start-up hooks. Run the
find_hooksfunction above with the service’sPYTHONPATHand alert on newsitecustomize.py,usercustomize.pyand.pthimport lines. Search access logs forPUT /datastore/requests whose query string holds.., a slash or an encoded form of either. - Watch for the release. Re-run
release_check.py. A PyPI version above 0.8.5, or a filled-in patched version on the advisory, closes the gap. Installing an unreleased development snapshot is the project’s call to bless, not mine.
To reproduce: save each script under the name in its first comment line and run it with python -I name.py. All four use only the standard library; release_check.py needs network access, and its output will change when the project ships a release.
What I could not check
- AWS’s transcripts or logs, the folder that received
sitecustomize.py, and the date AWS reported the flaw. - That 0.8.5 behaves as the model does when running. I started no MONAI Label server and sent nothing to any host; the path and hook scripts are arithmetic and harmless marker files.
- How many MONAI Label servers are reachable. I did not scan.
- Whether the second university patched, and the core-repository advisory that AWS filed first (it does not resolve anonymously).
- Gambit Security’s report, which AWS links for a second Cairn actor. I did not read it for this piece; our audit of Google’s exploit-agent claim covers the same autonomy question for a different campaign.
Sources
- AWS Security Blog, “Chinese-nexus actor’s Cairn AI agents found a zero-day on their own” (November 20, 17:30 UTC)
- The Register, November 20
- GHSA-qc22-rmgc-vg94, pull request 1915 and pull request 1940, read through GitHub’s API
- PyPI monailabel (0.8.5 wheel read in full) and Docker Hub projectmonai/monailabel
- CVE-2026-133968 in CVE Services and NVD; ARIN RDAP for the two indicator addresses; Cairn issue 8, a request for web login, open since May 21 with no comments








No Comment! Be the first one.