Microsoft’s agent-framework Carried a Credential Stealer on PyPI for 39 Minutes, Wiz Points to a Compromised Release-Pipeline Certificate, and 22 Hours Later PyPI Still Listed an Account Created That Day on 14 Microsoft Projects
Two releases of Microsoft’s agent-framework carried a startup-hook credential stealer on PyPI for 39 minutes; Wiz points to a compromised ESRP release-pipeline certificate, while PyPI still listed an...
Two releases of Microsoft’s agent-framework package on PyPI carried a credential stealer on November 17. By StepSecurity’s timestamps they were installable for 39 minutes in total (30 minutes 56 seconds for 1.26.1 and 8 minutes 5 seconds for 1.26.2) before PyPI quarantined them. How they reached Microsoft’s project is still told three different ways: SecurityWeek’s morning report says the method is unknown, SafeDep and StepSecurity point to a PyPI account created that same day, and a Wiz update posted at 14:00 UTC on November 18 says the attacker appears to have used a compromised certificate for Microsoft’s ESRP release service.
Table Of Content
- What happened, minute by minute
- Three accounts of how the releases got published
- What PyPI, GitHub and the download logs show
- PyPI: the clean release, and who is listed
- GitHub: the source repository returns 404
- Downloads: 427 of the bad versions on November 17
- What Wiz recovered from the webhook
- How the hook starts, and how to look without starting it
- Which Python flags skip a startup hook
- A read-only check that does not run the hook
- Sweeping many machines and lock files
- If you find it
- What is still unknown
- Sources
We checked the public records at 19:12 to 19:14 UTC on November 18, about 22 hours after the first upload. PyPI still listed that new account, vibiret, as a maintainer of agent-framework and 13 other projects, among them Semantic Kernel and the AutoGen packages. The microsoft/agent-framework repository on GitHub returned 404. PyPI’s download logs show 427 downloads of the two bad versions on November 17, a count of file fetches that cannot separate victims from scanners and mirrors. Everything below says which source each claim rests on, because the sources disagree in places.
What happened, minute by minute
All times are UTC on November 17, 2026, unless a date is given. The dated rows for PyPI come from our own reads of PyPI’s JSON; the rest come from the named sources.
| Time | Event | Source |
|---|---|---|
| Nov 12, 18:24:57 and 18:25:37 | Legitimate 1.26.0 uploaded as an sdist, then a wheel; agent-framework-core 1.26.0 was uploaded between 18:25:08 and 18:25:48 |
PyPI JSON (our read) |
| 20:35:20 | 1.26.1 uploaded, wheel only | StepSecurity (Wiz and SafeDep say 20:35) |
| 20:57 | SafeDep flags 1.26.1, 22 minutes after upload; Endor Labs says it detected both uploads within three minutes | SafeDep, Endor Labs |
| 21:06:16 | PyPI quarantines 1.26.1 | StepSecurity |
| 21:08:39 | 1.26.2 uploaded, 2 minutes 23 seconds after that quarantine; the stealer moves to new file names and adds GitHub Actions token requests | StepSecurity |
| 21:16:44 | PyPI quarantines 1.26.2 | StepSecurity |
| 22:12:19 | OSV’s malware record MAL-2026-20101 carries this published time (finders credited: Amazon Inspector and OX Security) | OSV |
| 23:18:29 | PyPA advisory PYSEC-2026-4388 carries this published time (Wiz credited as reporter, Mike Fiedler as coordinator, Microsoft as remediation developer) | OSV |
| Nov 18, 14:00 | Wiz updates its post with a root-cause claim and an analysis of the attacker’s webhook | Wiz |
Two outlets gave two different gaps, and both fit the timestamps. BleepingComputer wrote that the attacker published a second version “roughly 2.5 minutes later,” which matches StepSecurity’s 2 minutes 23 seconds after the first quarantine. SecurityWeek’s “roughly 33 minutes apart” is the gap between the two uploads, 33 minutes 19 seconds. For defenders the first gap is the one that matters: quarantining 1.26.1 did not end the publisher’s ability to upload.
Our arithmetic from StepSecurity’s times: 1.26.1 was installable for 30 minutes 56 seconds, 1.26.2 for 8 minutes 5 seconds, and 39 minutes 1 second together, with a 2 minute 23 second gap between them. OSV’s malware record carries a published time 1 hour 37 minutes after the first upload and the PyPA advisory 2 hours 43 minutes after it.
Three accounts of how the releases got published
The sources agree on what the wheels do. They differ, or say nothing, on how the files reached PyPI.
| Source and time | What it says about the upload |
|---|---|
| SecurityWeek, Nov 18, 06:05 ET | “The method used to publish the malicious packages remains unknown.” It adds that Wiz found no matching releases or malicious code in Microsoft’s main source repository, and that the new account’s involvement was unconfirmed. |
| SafeDep, updated Nov 18 | The account joined PyPI on Nov 17. “The join date points to vibiret as the account that uploaded 1.26.1 and 1.26.2.” It also says “How the account got maintainer access is not known.” |
| StepSecurity, Nov 18 | Its attack flow lists the account as created and added on Nov 17, and reports an uploader user-agent of RestSharp/106.13.0.0 on both wheels. It also says a missing attestation “does not identify the upload mechanism or establish a change from the legitimate release process.” |
| OpenSourceMalware, Nov 18, 05:43 UTC | “PyPI has quarantined the publisher, but the threat actor is still believed to have publishing access.” |
| PYSEC-2026-4388, modified Nov 18, 14:30 UTC | “PyPI Security worked with Microsoft to review the project’s accounts and complete remediation steps.” |
| Wiz, updated Nov 18, 14:00 UTC | “The attacker appears to have compromised a client certificate and private key for Microsoft ESRP (Engineering System Release Pipeline), the internal service Microsoft uses to sign and publish this package.” A first publish attempt from AWS was rejected by ESRP’s IP filtering; a second from Microsoft-owned IP space succeeded. “How the credentials were obtained is not yet known.” |
| BleepingComputer, Nov 18 | “It remains unclear how the attacker gained access to publish malicious releases under Microsoft’s official PyPI project.” It had asked Microsoft and had no reply at publication time. |
These accounts can all be true at once. A compromised signing-service certificate would explain how files reached PyPI from Microsoft’s own address space, and a new maintainer entry is a separate fact. No source connects the two, and Wiz’s post does not mention the account. We cannot tell from public pages which description, if any, is the whole path.
Wiz also reports that the attacker’s tooling identifies itself as Cairn, an open-source AI penetration-testing framework, and that a run of the stealer on the attacker’s own machine captured an AI coding-agent configuration that appears to be the open-source Pi harness backed by a GLM-family model. That is Wiz’s reading of the traces. We reported on Cairn’s own server in October, when its code had no login.
What PyPI, GitHub and the download logs show
These are our own reads, taken between 19:12 and 19:14 UTC on November 18.
PyPI: the clean release, and who is listed
PyPI’s JSON endpoints for 1.26.1 and 1.26.2 return 404, and the latest release of agent-framework is 1.26.0. The HTML pages for the two bad versions answer scripts with a bot-challenge page, so we could not read PyPI’s own quarantine notice. Every release from 1.15.0 to 1.26.0 has both a wheel and an sdist, which fits the single-wheel uploads StepSecurity, SafeDep and Endor describe. PyPI’s Simple API shows no provenance for 1.25.0 or 1.26.0, so a missing attestation does not set the bad wheels apart.
The project page for agent-framework lists two maintainers, microsoft and vibiret. The profile page of vibiret says it joined on November 17, 2026 and lists 14 projects:
| Project | Maintainers on the project page | Latest release |
|---|---|---|
agent-framework |
microsoft, vibiret | 1.26.0, Nov 12 |
agent-framework-core (the framework’s code) |
microsoft and five individual accounts, not vibiret | 1.26.0, Nov 12 |
agent-framework-openai, -purview, -redis, -tools, -postgres |
microsoft, vibiret | Nov 12 |
semantic-kernel |
edvan_msft, microsoft, vibiret | 1.47.0, Nov 5 |
autogen-core, autogen-ext, autogen-agentchat |
microsoft, vibiret | 0.7.5, Sep 30, 2025 |
pyautogen |
microsoft, vibiret | 0.10.0, Jul 15, 2025 |
agent-framework-eval, agent-framework-workflow |
microsoft, vibiret | placeholder releases, Sep 2025 |
agent-framework-azure (archived) |
on the profile; page not read | Sep 2, 2025 per the profile |
SafeDep’s table covers agent-framework and five related projects. The profile lists eight more: Semantic Kernel, the four AutoGen packages, the two placeholder packages and the archived one. A public profile does not show when each role was granted, and the PyPA advisory says PyPI Security worked with Microsoft on the project’s accounts, so we cannot say whether the listing is stale, intended or a gap. What the records do show: none of the 13 active projects has a release dated after November 12, and OSV has no malware advisory for agent-framework-core or for any of the other 13 projects on the profile. A quarantined upload would not appear in PyPI’s JSON, so the first of those two checks is weaker than the second.
GitHub: the source repository returns 404
SecurityWeek wrote that Microsoft’s Agent Framework repository was “inaccessible at the time of writing,” and that other Microsoft repositories, including ONNX Runtime projects, had also disappeared. At 19:13 to 19:14 UTC anonymous requests to microsoft/agent-framework returned 404 from both the GitHub API and the web page, as did the issue (number 10411) that SecurityWeek links for a maintainer’s update. The API also returned 404 for microsoft/onnxruntime and microsoft/onnxruntime-genai, while microsoft/semantic-kernel, microsoft/autogen, microsoft/vscode, microsoft/TypeScript and microsoft/durabletask-python answered 200. A 404 does not say whether a repository was deleted or made private, and it means we could not check for a python-1.26.1 tag ourselves.
Downloads: 427 of the bad versions on November 17
ClickPy is a public PyPI download dashboard, and we read its data through ClickHouse’s public playground. It counts per-version downloads by UTC day, where a download is a file fetch logged by PyPI’s CDN:
| Day | 1.26.0 | 1.26.1 | 1.26.2 | All versions |
|---|---|---|---|---|
| Nov 15 | 1,098 | 0 | 0 | 2,852 |
| Nov 16 | 1,314 | 0 | 0 | 6,189 |
| Nov 17 | 1,544 | 266 | 161 | 7,542 |
The 427 downloads of the two bad versions are 5.7 percent of the package’s 7,542 that day. A download is a file fetch, not an install: mirrors, caches and the security vendors that flagged these wheels within minutes all fetch files too, and ClickPy had no rows for November 18 yet. Outlets quote monthly totals from about 190,000 (SecurityWeek, Endor Labs) to roughly 200,000 (BleepingComputer), and Wiz says about 41,000 a week; ClickPy’s total for November 12 to 17 is 34,627, about 5,800 a day, which is in the same range.
What Wiz recovered from the webhook
Wiz says the stealer posted to a public webhook.site address, that the attacker’s token was on the free tier, and that a free address accepts at most 100 requests and logs none after that. Wiz analyzed the 50 requests that were stored: four came from the attacker’s machines, 29 looked like sandboxes, vendor scanning and tests, and the other 17 represented three unique victims whose data was exfiltrated. Wiz warns that those requests can hold working cloud, CI and registry credentials. Wiz says it could observe only part of the operation, so the three victims are what that sample showed, not a count of installs.
How the hook starts, and how to look without starting it
Both bad wheels keep the real dependency on agent-framework-core 1.26.0, so the framework keeps working. The stealer rides on a .pth file in site-packages: agent_framework_meta.pth in 1.26.1 (one line, 28 bytes) and af_runtime_diag.pth in 1.26.2 (23 bytes). The Python docs say “lines starting with import (followed by space or tab) are executed with exec()” and that “Python startup option -S blocks this.” The 3.15.2 docs add that import lines in .pth files still run during the deprecation period and, in the docs’ words, “are deprecated and will be silently ignored in Python 3.18 and 3.19.” Our .pth audit tutorial covers the 3.15 migration; SafeDep notes that the same shape, a one-line .pth that imports a module which forks a collector, appeared in the LiteLLM 1.107.0 release we covered in our LiteLLM report.
Nothing below runs, downloads or contacts the real malware. The only inputs are the one-line .pth texts that the write-ups print, empty stand-in files with the known names, and a stand-in module that prints one line. Everything ran on Windows 11 with Python 3.13.14.
Which Python flags skip a startup hook
This script builds a throwaway virtual environment, plants the 1.26.1 .pth text plus a harmless module with the same name, and starts Python five ways:
# startup_demo.py
"""A harmless stand-in that shows when Python runs a .pth import line, and that -S skips it."""
import pathlib
import subprocess
import sys
import venv
env = pathlib.Path(sys.argv[1] if len(sys.argv) > 1 else "demo_env")
venv.EnvBuilder(with_pip=True, clear=True).create(env)
py = str(env / ("Scripts" if sys.platform == "win32" else "bin") / "python")
# Ask the new environment where its site-packages folder is (no .pth file exists yet).
site = pathlib.Path(subprocess.check_output(
[py, "-c", "import sysconfig; print(sysconfig.get_paths()['purelib'])"], text=True).strip())
# The one-line .pth text is the public indicator; the module it imports only prints a message.
(site / "agent_framework_meta.pth").write_bytes(b"import agent_framework_meta\n")
hook = site / "agent_framework_meta"
hook.mkdir()
(hook / "__init__.py").write_text(
"import sys\nsys.stderr.write('[demo] startup hook ran' + chr(10))\n", encoding="utf-8")
def run(*args):
print("$ python " + " ".join(args))
r = subprocess.run([py, *args], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
text = r.stdout.replace(str(env.resolve()), env.name).rstrip()
print(text or "(no output)")
print()
run("-c", "print('hello')")
run("-S", "-c", "print('hello')")
run("-I", "-c", "print('hello')")
run("-m", "pip", "--version")
run("-S", "-m", "pip", "--version")
Run it as python startup_demo.py demo_env:
$ python -c print('hello')
[demo] startup hook ran
hello
$ python -S -c print('hello')
hello
$ python -I -c print('hello')
[demo] startup hook ran
hello
$ python -m pip --version
[demo] startup hook ran
pip 26.1.2 from demo_env\Lib\site-packages\pip (python 3.13)
$ python -S -m pip --version
demo_env\Scripts\python.exe: No module named pip
The hook ran for a plain start, for isolated mode (-I) and for pip --version, and it was skipped with -S, the option the docs name. The consequence for cleanup: running pip uninstall inside an affected environment would start the stealer again, and python -S cannot run pip at all because site-packages is not on the path. Delete the files with file tools, or rebuild the environment.
A read-only check that does not run the hook
This script walks the folders you give it, finds every site-packages or dist-packages, and compares each .pth file’s SHA-256 with the two published hashes. It also flags the known hook names with different content, the installed 1.26.1 or 1.26.2 metadata and the known stealer file names, and lists other .pth files that run code so you can review them. Run it with python -S:
# pthcheck.py
"""Look for the agent-framework 1.26.1 and 1.26.2 startup hooks without running them.
Run it with -S so Python does not process .pth files before this script starts:
python -S pthcheck.py ROOT [ROOT ...]
Exit code 1 means at least one known indicator was found.
"""
import hashlib
import os
import re
import sys
# SHA-256 of the two one-line .pth files, as published by SafeDep and Socket.
KNOWN_PTH = {
"21f28e8517a10ffe431f8d68f5875c85eca4001ae6d118322b0a41873998eb5e": "agent_framework_meta.pth (1.26.1)",
"325e7e9f0ec94e41ad1a1b7a3f18a6b8b5bffece2e2b97b8d3369eb967452f93": "af_runtime_diag.pth (1.26.2)",
}
HOOK_NAMES = {"agent_framework_meta.pth", "af_runtime_diag.pth"}
STEALER_FILES = ["agent_framework_meta/_telemetry.py", "af_runtime_diag.py"]
BAD_VERSIONS = {"1.26.1", "1.26.2"}
def site_dirs(roots):
"""Yield every site-packages or dist-packages folder under the given roots."""
for root in roots:
for here, dirs, _files in os.walk(os.path.normpath(root)):
dirs.sort()
if os.path.basename(here) in ("site-packages", "dist-packages"):
yield here
dirs.clear() # no need to walk into the packages themselves
def scan(site):
hits, startup = [], []
for name in sorted(os.listdir(site)):
path = os.path.join(site, name)
if name.endswith(".pth") and os.path.isfile(path):
data = open(path, "rb").read()
digest = hashlib.sha256(data).hexdigest()
if digest in KNOWN_PTH:
hits.append((path, "hash matches " + KNOWN_PTH[digest]))
elif name in HOOK_NAMES:
hits.append((path, "known hook name, different content"))
elif any(line.startswith(("import ", "import\t"))
for line in data.decode("utf-8", "replace").splitlines()):
startup.append(path)
m = re.fullmatch(r"agent_framework-(\d+\.\d+\.\d+)\.dist-info", name)
if m and m.group(1) in BAD_VERSIONS:
hits.append((path, "agent-framework " + m.group(1) + " is installed"))
for rel in STEALER_FILES:
path = os.path.join(site, *rel.split("/"))
if os.path.exists(path):
hits.append((path, "known stealer file name"))
return hits, startup
def main(roots):
scanned = found = 0
for site in site_dirs(roots):
scanned += 1
try:
hits, startup = scan(site)
except OSError as exc:
print("cannot read", site, exc)
continue
for path, why in hits:
print("FOUND ", path, "-", why)
for path in startup:
print("review", path, "- another .pth file that runs code at startup")
found += len(hits)
print("scanned %d site-packages folders, %d indicator(s)" % (scanned, found))
return 1 if found else 0
if __name__ == "__main__":
if len(sys.argv) < 2:
sys.exit(__doc__)
sys.exit(main(sys.argv[1:]))
To test it without touching a real system, this script builds three made-up folders and a pair of made-up lock files. It prints the size and SHA-256 of the two one-line files, which reproduce the published hashes (21f28e85… and 325e7e9f…) from the public text alone:
# make_trees.py
"""Build made-up site-packages folders to test pthcheck.py. Nothing here is the real malware."""
import hashlib
import pathlib
import sys
root = pathlib.Path(sys.argv[1] if len(sys.argv) > 1 else "trees")
def put(path, text):
p = root / path
p.parent.mkdir(parents=True, exist_ok=True)
p.write_bytes(text.encode("utf-8")) # bytes, so Windows adds no carriage returns
return p
# 1. A clean environment: 1.26.0 plus one ordinary startup hook (setuptools ships a similar one).
put("clean/lib/python3.13/site-packages/distutils-precedence.pth",
"import os; os.environ.get('SETUPTOOLS_USE_DISTUTILS')\n")
put("clean/lib/python3.13/site-packages/agent_framework-1.26.0.dist-info/METADATA",
"Name: agent-framework\nVersion: 1.26.0\n")
# 2. An environment with the indicators of both releases. The .pth text is public: one import line each.
site = "infected/Lib/site-packages/"
p1 = put(site + "agent_framework_meta.pth", "import agent_framework_meta\n")
p2 = put(site + "af_runtime_diag.pth", "import af_runtime_diag\n")
put(site + "agent_framework-1.26.2.dist-info/METADATA", "Name: agent-framework\nVersion: 1.26.2\n")
put(site + "agent_framework_meta/_telemetry.py", "# stand-in: empty file with the known name, not the real module\n")
put(site + "af_runtime_diag.py", "# stand-in: empty file with the known name, not the real module\n")
# 3. An environment where someone edited the hook, so its hash no longer matches.
put("edited/lib/python3.13/site-packages/agent_framework_meta.pth", "import agent_framework_meta; pass\n")
# 4. Made-up lock files.
put("locks/requirements.txt", "fastapi==0.162.7\nagent-framework==1.26.1\nuvicorn==0.54.0\n")
put("locks/poetry.lock",
'[[package]]\nname = "agent-framework"\nversion = "1.26.2"\n'
'description = "Microsoft Agent Framework for building AI Agents with Python."\n')
for p in (p1, p2):
data = p.read_bytes()
print("%-22s %2d bytes sha256 %s" % (p.name, len(data), hashlib.sha256(data).hexdigest()))
agent_framework_meta.pth 28 bytes sha256 21f28e8517a10ffe431f8d68f5875c85eca4001ae6d118322b0a41873998eb5e
af_runtime_diag.pth 23 bytes sha256 325e7e9f0ec94e41ad1a1b7a3f18a6b8b5bffece2e2b97b8d3369eb967452f93
Now scan. The first folder is the infected stand-in, the second a clean environment with one ordinary startup hook, and the third runs all three together (the exit code is 1 when anything is found):
python -S pthcheck.py trees\infected
python -S pthcheck.py trees\clean
python -S pthcheck.py trees
FOUND trees\infected\Lib\site-packages\af_runtime_diag.pth - hash matches af_runtime_diag.pth (1.26.2)
FOUND trees\infected\Lib\site-packages\agent_framework-1.26.2.dist-info - agent-framework 1.26.2 is installed
FOUND trees\infected\Lib\site-packages\agent_framework_meta.pth - hash matches agent_framework_meta.pth (1.26.1)
FOUND trees\infected\Lib\site-packages\agent_framework_meta\_telemetry.py - known stealer file name
FOUND trees\infected\Lib\site-packages\af_runtime_diag.py - known stealer file name
scanned 1 site-packages folders, 5 indicator(s)
review trees\clean\lib\python3.13\site-packages\distutils-precedence.pth - another .pth file that runs code at startup
scanned 1 site-packages folders, 0 indicator(s)
review trees\clean\lib\python3.13\site-packages\distutils-precedence.pth - another .pth file that runs code at startup
FOUND trees\edited\lib\python3.13\site-packages\agent_framework_meta.pth - known hook name, different content
FOUND trees\infected\Lib\site-packages\af_runtime_diag.pth - hash matches af_runtime_diag.pth (1.26.2)
FOUND trees\infected\Lib\site-packages\agent_framework-1.26.2.dist-info - agent-framework 1.26.2 is installed
FOUND trees\infected\Lib\site-packages\agent_framework_meta.pth - hash matches agent_framework_meta.pth (1.26.1)
FOUND trees\infected\Lib\site-packages\agent_framework_meta\_telemetry.py - known stealer file name
FOUND trees\infected\Lib\site-packages\af_runtime_diag.py - known stealer file name
scanned 3 site-packages folders, 6 indicator(s)
The edited hook in the third folder shows why the script also matches by name: a hash sweep alone would miss a copy whose content was changed. The same scan on the throwaway environment from the previous step, whose hook the demo actually ran, flags the file without starting it:
FOUND demo_env\Lib\site-packages\agent_framework_meta.pth - hash matches agent_framework_meta.pth (1.26.1)
scanned 1 site-packages folders, 1 indicator(s)
Sweeping many machines and lock files
On Linux or in Git Bash, a size filter plus a hash match finds the two files even if they were renamed (replace trees with / on a real host):
find trees -name '*.pth' -size -40c -exec sha256sum {} + | grep -E '^(21f28e85|325e7e9f)'
325e7e9f0ec94e41ad1a1b7a3f18a6b8b5bffece2e2b97b8d3369eb967452f93 *trees/infected/Lib/site-packages/af_runtime_diag.pth
21f28e8517a10ffe431f8d68f5875c85eca4001ae6d118322b0a41873998eb5e *trees/infected/Lib/site-packages/agent_framework_meta.pth
In PowerShell on Windows (replace trees with C:\):
$bad = '21F28E8517A10FFE431F8D68F5875C85ECA4001AE6D118322B0A41873998EB5E','325E7E9F0EC94E41AD1A1B7A3F18A6B8B5BFFECE2E2B97B8D3369EB967452F93'
Get-ChildItem trees -Recurse -Filter *.pth -File |
Get-FileHash -Algorithm SHA256 |
Where-Object { $bad -contains $_.Hash } |
ForEach-Object { '{0} {1}' -f $_.Hash.Substring(0, 8), (Resolve-Path -Relative $_.Path) }
325E7E9F .\trees\infected\Lib\site-packages\af_runtime_diag.pth
21F28E85 .\trees\infected\Lib\site-packages\agent_framework_meta.pth
For lock files and requirement lists, two greps cover the common layouts (the second handles the two-line name and version entries in poetry.lock):
grep -rnE 'agent[-_]framework(==|-)1\.26\.[12]' trees/locks
grep -rn -A1 '^name = "agent-framework"' trees/locks | grep -E 'version = "1\.26\.[12]"'
trees/locks/requirements.txt:2:agent-framework==1.26.1
trees/locks/poetry.lock-3-version = "1.26.2"
Check anything built or installed after 20:35 UTC on November 17 that installed agent-framework without an exact pin, including container images and CI caches; StepSecurity notes that “registry quarantine does not remove copies already downloaded.” Our SBOM tutorial shows why a scanner that asks only PyPI can miss a release PyPI has already removed; OSV’s MAL-2026-20101 covers both versions.
If you find it
The advice below follows Wiz, StepSecurity and OX Security; the sweeps above are ours.
- Search proxy and DNS logs for the webhook path
d381fd80-ec62-42ad-8f5c-d1b15103c9bbon webhook[.]site and block that service from build infrastructure. Wiz writes: “A 200 means that host’s data was accepted. A 410/429 suggests it was rejected.” - Remove the files with file tools, or rebuild from a clean environment pinned to 1.26.0 with hash checking, which StepSecurity and Endor Labs both suggest. From our test above: do not start Python or pip in the affected environment first.
- Rotate every secret reachable from that host or runner, including tokens the code requested itself. Wiz says stolen managed-identity and OIDC-exchanged tokens are valid for up to 24 hours, and that for 1.26.2 on GitHub Actions workflows with
id-token: writethe OIDC tokens should be treated as exposed, with the Entra federated credentials that trust those workflows reviewed.
What is still unknown
- How the uploads were made. Wiz points to an ESRP certificate; SafeDep and StepSecurity point to the new account; SecurityWeek and BleepingComputer called it unknown in the morning. Microsoft had not answered BleepingComputer, and the maintainer update SecurityWeek cites sits in a GitHub issue that returns 404 to us.
- Whether
vibiretuploaded anything, how it got its roles, and what PyPI’s listing of it on 14 projects at 19:13 UTC means. - How many hosts ran the stealer. Wiz saw three successful victims in the 50 requests that were logged, ClickPy shows 427 downloads, and neither is a count of victims.
- Whether the GitHub repository and the ONNX Runtime repositories are coming back, and whether the project will publish attested releases, which none of the 1.25.0 or 1.26.0 files has.
Sources
- Reports: Wiz, StepSecurity, SafeDep, Socket, Endor Labs, OX Security, OpenSourceMalware, SecurityWeek and BleepingComputer.
- Records: agent-framework on PyPI, the vibiret profile, OSV MAL-2026-20101 and PYSEC-2026-4388, and ClickPy.
- Docs: Python site module and command-line options.








No Comment! Be the first one.