TRENDING
A person sweeping a metal detector across a wet sandy beach with a sea fort on the horizon
November 22, 2026
How to Write YARA Rules With YARA-X to Hunt Malicious Python .pth Startup Files and Measure False Positives Before You Trust Them
A peeling black-and-white metal door standing ajar, with a dark empty hall and bright windows beyond
November 22, 2026
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
A hand paging through index cards in an open wooden library card-catalog drawer labeled Agriculture, with a second drawer open below to the right
November 22, 2026
Microsoft Tells Customers Unauthorized Parties Read Admin Email Addresses and Tenant Metadata Through an Entra Connect Health Flaw Introduced July 23, but Gives No Tenant Count or Start Date, and Its Own Docs Send Tenant Security Notices to the Same Kinds of Contacts
Swimmers in separate lanes of a blue swimming pool, seen from above the water, with lane lines running across the picture
November 22, 2026
How to Size a PostgreSQL Connection Pool in Python: Find Where Throughput Stops Growing, Split max_connections Across Workers, and Stop Slow Handlers From Hoarding Connections
Workers in caps lean over a 1913 Ford assembly line, each assembling parts as they pass on the moving line
November 22, 2026
OpenAI’s Performance Factory Turns Regression Response Into a Task Queue for Agents, but Its Numbers Stop at 600 Root-Caused Cases in 1,700 Investigations and a 70% Grade on 100 Suggestions, and in a Toy World Each of Its Reviewer’s Two Counterfactual Questions Can Return a Confident Wrong Answer
22 Nov 2026
SXZ.io SXZ.io
  • Home
Search the Site
Popular Searches:
Technology Amazon AI
Recent Posts
The sun setting over the sea behind a pyramid-shaped stone monument at Cape Soya, the northernmost point of Japan
How to Retire an API Endpoint in FastAPI: Send Deprecation and Sunset Headers, Find the Clients Still Calling It, Schedule Brownouts, and Block an Early Removal With oasdiff
November 22, 2026
Brass sextant in an open wooden case inside a museum display, an instrument for measuring the angle to the horizon
MIT Technology Review’s “Most Misunderstood Graph” Update Reports METR’s Judgment Findings Mostly Fairly, but It Never Says Each Point Is a 50% Success Rate or Gives the New 3.6-Month Doubling Time and 2.1 to 4.9 Month Range, and It Credits OpenAI With a Comparison METR Built
November 22, 2026
Brass telescope on a wooden tripod inside a white observatory dome with the roof slit open to the sky
Rackspace Says Leaked Credentials Let an Intruder Act as Legitimate Users in Some Spot Customer Organizations and Reach Their Kubernetes Secrets, a Platform9 Co-Founder Names a Breached Observability System as the Root Cause, and the Status Page Says Only “System Maintenance Operations”
November 22, 2026
SXZ.io SXZ.io
  • Home

Categories

Articles 310 Posts
News 316 Posts
Learning Hub 282 Posts
Home/Articles/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
Articles

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...

November 21, 2026 22 Min Read
11

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 monailabel on 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, the ANNOTATOR role 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 ..\..\x is refused only because it starts with a dot; on Windows the same string is cut to x.
  • A symlinked label folder is refused on this machine’s real filesystem, because realpath resolves 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 to main.py concerns a dataset download, not the bind address or the PYTHONPATH line. 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 monailabel on each host and a look for the projectmonai/monailabel container 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.1 or firewall port 8000.
  • Turn on login, and do not stop there. MONAI_LABEL_AUTH_ENABLE=True expects a Keycloak-style identity provider (the default realm address in config.py points 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, planting sitecustomize.py there needs write access to the app folder’s top level; the server creates model, lib, logs and bin under it (main.py lines 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_hooks function above with the service’s PYTHONPATH and alert on new sitecustomize.py, usercustomize.py and .pth import lines. Search access logs for PUT /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

Tags:

AI Agent SecurityAWS SecurityCairnMONAI LabelPath TraversalVulnerability DisclosureZero-Day

Share

A hand paging through index cards in an open wooden library card-catalog drawer labeled Agriculture, with a second drawer open below to the right
Previous Post

Microsoft Tells Customers Unauthorized Parties Read Admin Email Addresses and Tenant Metadata Through an Entra Connect Health Flaw Introduced July 23, but Gives No Tenant Count or Start Date, and Its Own Docs Send Tenant Security Notices to the Same Kinds of Contacts

A person sweeping a metal detector across a wet sandy beach with a sea fort on the horizon
Next Post

How to Write YARA Rules With YARA-X to Hunt Malicious Python .pth Startup Files and Measure False Positives Before You Trust Them

No Comment! Be the first one.

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Latest
22 Nov
How to Retire an API Endpoint in FastAPI: Send Deprecation and Sunset Headers, Find the Clients Still Calling It, Schedule Brownouts, and Block an Early Removal With oasdiff
22 Nov
MIT Technology Review’s “Most Misunderstood Graph” Update Reports METR’s Judgment Findings Mostly Fairly, but It Never Says Each Point Is a 50% Success Rate or Gives the New 3.6-Month Doubling Time and 2.1 to 4.9 Month Range, and It Credits OpenAI With a Comparison METR Built
Trending
November 22, 2026
How to Retire an API Endpoint in FastAPI: Send Deprecation and Sunset Headers, Find the Clients Still Calling It, Schedule Brownouts, and Block an Early Removal With oasdiff
November 22, 2026
MIT Technology Review’s “Most Misunderstood Graph” Update Reports METR’s Judgment Findings Mostly Fairly, but It Never Says Each Point Is a 50% Success Rate or Gives the New 3.6-Month Doubling Time and 2.1 to 4.9 Month Range, and It Credits OpenAI With a Comparison METR Built
November 22, 2026
Rackspace Says Leaked Credentials Let an Intruder Act as Legitimate Users in Some Spot Customer Organizations and Reach Their Kubernetes Secrets, a Platform9 Co-Founder Names a Breached Observability System as the Root Cause, and the Status Page Says Only “System Maintenance Operations”
November 21, 2026
How to Write YARA Rules With YARA-X to Hunt Malicious Python .pth Startup Files and Measure False Positives Before You Trust Them
November 21, 2026
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
November 21, 2026
Microsoft Tells Customers Unauthorized Parties Read Admin Email Addresses and Tenant Metadata Through an Entra Connect Health Flaw Introduced July 23, but Gives No Tenant Count or Start Date, and Its Own Docs Send Tenant Security Notices to the Same Kinds of Contacts

Related Posts

Blue-lit server racks in a modern data center, illustrating the compute infrastructure behind the AI boom.
Articles

The AI Boom Is Spending Real Money Before Proving Real Returns

June 7, 2026
Technician working with a laptop beside server racks, representing enterprise AI retrieval infrastructure
Articles

Google’s Agentic RAG Push Makes Enterprise AI Less of a One-Shot Guess

June 7, 2026
A person with a laptop and smartphone, representing digital attention and AI-assisted work
Articles

AI Chatbots Are Making Attention a Design Problem

June 7, 2026
A customer-support representative wearing a headset against a dark studio background.
Articles

The Meta AI Support Hack Was a Plain Old Authorization Failure

June 7, 2026
SXZ.io SXZ.io
  • [email protected]

Categories

Articles
Learning Hub
News

All Rights Reserved by SXZ.io ©2026