top of page

Microsoft Agent Framework PyPI Compromise Targets Tokens

Writer: Inception Security
Inception Security
22 hours ago
10 min read
Bright five-panel comic with a white footer. In the top left, a smiling woman in a red shirt and a helper pass a cardboard box labeled TRUSTED UPDATE. In the top right, she presses a green PYTHON START button as a grinning square PTH FILE pops out of a wooden box. In the bottom left, the PTH FILE stands at a BUILD RUNNER desk under a CLOUD TOKENS sign, holding a paper while six gold TOKENS keys hang on the wall. In the bottom middle, it feeds stacked gold coins into a glass WEBHOOK tube. In the bottom right, a smiling defender holds a HUNT BOARD clipboard with PTH FILE, METADATA and WEBHOOK checked, a CLEAN BUILD crate, and keys tagged ROTATE. The footer reads Hunt the hook. Rebuild. Then rotate.

What this means for your clients: For about 40 minutes on November 17, Microsoft's official Python package for AI agents carried code that collects passwords and cloud keys, so ask your IT provider whether any machine installed it that afternoon.


On November 17, two releases of agent-framework, the official Microsoft Agent Framework PyPI package, shipped a credential stealer. Version 1.26.1 was live from 1:35 to 2:06 PM MST and 1.26.2 from 2:08 to 2:16 PM MST, per StepSecurity's timestamps. GHSA-764m-3ppc-5m73, also OSV MAL-2026-20101, tracks it as a malicious release with no CVE. This is a supply chain compromise of the real project, not a lookalike package.


Elastic Security Labs flagged 1.26.1 six minutes after upload. The last clean release is 1.26.0. Microsoft told The Register it made some repositories private while it investigates, and GHSA has not attributed the attack. The short window is less comforting than it looks, because cached copies in mirrors and images can still install.


How the Microsoft Agent Framework PyPI stealer runs


Both wheels dropped a .pth file into site-packages, which Python processes at every interpreter start, so any Python launch there could run the stealer, import or not. In 1.26.1 the file was agent_framework_meta.pth, containing "import agent_framework_meta", which loaded a new _telemetry.py. In 1.26.2 the pair became af_runtime_diag.pth and af_runtime_diag.py, so, as Wiz notes, hunting only the first names misses the second release. The stealer sets an _AF_TEL=1 marker, then forks a detached child on Linux or starts a thread on Windows. StepSecurity notes the child can outlive the process that started it.


What the credential stealer takes and tries to mint


It collected environment secrets, secret-looking values from up to 300 other processes' environ files under /proc, and credential files from Azure CLI, pip, npm, git, Docker, Hugging Face and Azure DevOps agents. It then attempted to request tokens: an Azure DevOps pipeline OIDC token, managed identity tokens for 12 resources through IMDS or the App Service identity endpoint, and, in 1.26.2, GitHub Actions OIDC tokens. Everything left in one encoded HTTPS POST to a webhook[.]site URL. Elastic warns, "Those tokens are how a compromised build can reach the Azure subscription behind it," and Wiz says such tokens stay valid for up to 24 hours.


Elastic says the Azure DevOps request omits serviceConnectionId, so it is unclear whether it returns a usable token. The GitHub token needs id-token: write, and Azure access needs an Entra ID federated credential trusting that workflow. Wiz's analysis of the capped free-tier webhook log found 17 requests representing three unique successful victim exfiltrations; requests past the cap went unlogged, so that is not a victim count.


Wiz says the attacker appears to have compromised a client certificate and private key for Microsoft ESRP, the internal service that signs and publishes the package, and reports the tooling identified itself as Cairn, an open-source AI penetration-testing framework. StepSecurity says its evidence does not establish the access vector. The second release went up 2 minutes 23 seconds after the first was quarantined.


Why MSPs should care


Many MSPs run a shared build agent or self-hosted runners with broad Azure rights, beside laptops signed in to Azure CLI. In our judgment, one unpinned install in that window could hand over the service connection that deploys to a client's subscription. Know each runner's owner, identity and reach.


Contain, rebuild, then rotate


Isolate affected hosts and runners. StepSecurity warns against running pip or any Python inside the affected environment, because interpreter startup can fire the hook again. Kill any detached collector and rebuild from a clean base, not in place. Pin 1.26.0 in a hash-pinned lockfile. Block 1.26.1 and 1.26.2 in internal mirrors and artifact caches like Artifactory or Nexus, because cached copies outlive PyPI's removal.


Then do secret rotation from a clean machine: environment secrets, Azure CLI sessions, Azure DevOps PATs and service connections, registry tokens, git credentials and CI/CD secrets. Re-register exposed self-hosted runners. Rotation does not necessarily revoke tokens already issued, so review managed identity and federated credential sign-ins. In our judgment, also limit id-token: write and allowlist runner egress.


How to hunt


We have not run these in a live SIEM; tune them to your field names and test before trusting a clean result. Hunts start at 2026-11-17T20:35:00Z, the first upload. Splunk assumes Sysmon plus a proxy index, Elastic assumes Elastic Defend, CrowdStrike assumes Falcon telemetry, and KQL assumes Defender for Endpoint. Hosted CI runners usually have no EDR, so there the evidence is CI logs, lockfiles and cloud sign-in logs. Every YOUR_ name is a placeholder.


Test 1: where agent-framework is installed


This 90-day inventory, our choice of window, lists hosts where agent-framework or agent_framework appears in a command line, parent command line, file path or connecting process. A long-running service that imported it earlier can show nothing, so in our judgment also list site-packages from outside Python or check image scans.


Field mapping: Splunk reads Sysmon EID 1 and 11, Elastic includes already_running events, Falcon adds SyntheticProcessRollup2 but lacks parent command lines, and KQL adds network events.


False positives: every legitimate install, 1.26.0 and earlier.


Splunk


index=YOUR_SYSMON_INDEX (EventCode=1 OR EventCode=11) earliest=-90d latest=now
| eval subject=lower(coalesce(CommandLine, "")." ".coalesce(TargetFilename, "")), parent=lower(coalesce(ParentCommandLine, ""))
| eval where_seen=case(match(subject, "agent[-_]framework"), "process or file", match(parent, "agent[-_]framework"), "child of an agent-framework process", true(), null())
| where isnotnull(where_seen)
| stats count AS events values(Image) AS images values(EventCode) AS event_codes max(_time) AS last_seen BY host where_seen
| convert ctime(last_seen)

Elastic


FROM logs-endpoint.events.*
| WHERE @timestamp >= NOW() - 90 days
| EVAL subject = TO_LOWER(CONCAT(COALESCE(process.command_line, ""), " ", COALESCE(file.path, ""))), parent = TO_LOWER(COALESCE(process.parent.command_line, ""))
| EVAL where_seen = CASE(subject RLIKE ".*agent[-_]framework.*", "process or file", parent RLIKE ".*agent[-_]framework.*", "child of an agent-framework process", NULL)
| WHERE where_seen IS NOT NULL
| STATS events = COUNT(*), images = VALUES(process.executable), actions = VALUES(event.action), last_seen = MAX(@timestamp) BY host.name, where_seen
| SORT host.name

CrowdStrike


// set the time picker to the last 90 days
#event_simpleName=/^(ProcessRollup2|SyntheticProcessRollup2)$|Written$/
| case {
    CommandLine=/agent[-_]framework/i | where_seen := "process" ;
    TargetFileName=/agent[-_]framework/i | where_seen := "file" }
| groupBy([aid, where_seen], function=[count(as=events), collect([ImageFileName, #event_simpleName]), max(@timestamp, as=last_seen)])

Microsoft KQL


let af = @"(?i)agent[-_]framework";
union
    (DeviceProcessEvents
    | where Timestamp > ago(90d)
    | extend WhereSeen = case(ProcessCommandLine matches regex af, "process", InitiatingProcessCommandLine matches regex af, "child of an agent-framework process", ""), Item = FolderPath),
    (DeviceFileEvents
    | where Timestamp > ago(90d)
    | extend WhereSeen = iff(FolderPath matches regex af, "file", ""), Item = FolderPath),
    (DeviceNetworkEvents
    | where Timestamp > ago(90d)
    | extend WhereSeen = iff(InitiatingProcessCommandLine matches regex af, "network", ""), Item = InitiatingProcessFolderPath)
| where isnotempty(WhereSeen)
| summarize Events = count(), Items = make_set(Item, 20), LastSeen = max(Timestamp) by DeviceName, WhereSeen
| order by DeviceName asc

Hunt 1: startup hook files on disk


This hunt finds writes of agent_framework_meta.pth, af_runtime_diag.pth or af_runtime_diag.py, or _telemetry.py inside agent_framework_meta, since that name alone is generic. StepSecurity also advises checking __pycache__ for these modules.


Field mapping: Sysmon EID 11 carries no hash, so Splunk matches names only; Elastic, Falcon and KQL also match the published file hashes.


False positives: we expect none, since these names come from the malicious wheels.


Splunk


index=YOUR_SYSMON_INDEX EventCode=11 earliest=1794947700 latest=now
| eval path=lower(TargetFilename), file=replace(path, "^.*[\\\\/]", "")
| where in(file, "agent_framework_meta.pth", "af_runtime_diag.pth", "af_runtime_diag.py") OR match(path, "agent_framework_meta[\\\\/]_telemetry[.]py$")
| stats min(_time) AS first_seen values(TargetFilename) AS files values(Image) AS writers BY host
| convert ctime(first_seen)

Elastic


FROM logs-endpoint.events.file-*
| WHERE @timestamp >= TO_DATETIME("2026-11-17T20:35:00Z") AND event.action == "creation"
| EVAL path = TO_LOWER(file.path)
| WHERE file.name IN ("agent_framework_meta.pth", "af_runtime_diag.pth", "af_runtime_diag.py")
    OR path RLIKE """.*agent_framework_meta[\\/]_telemetry[.]py"""
    OR file.hash.sha256 IN ("21f28e8517a10ffe431f8d68f5875c85eca4001ae6d118322b0a41873998eb5e", "39fa329f2a93f734b0bb8f5adb203ea3331d1ae479832a5015a54cb17aabd663", "c275ccbe520ef3c0f02dc6a35389e427f9f1b4e0b12e140cd7bf7179ce143f02", "325e7e9f0ec94e41ad1a1b7a3f18a6b8b5bffece2e2b97b8d3369eb967452f93", "54d885b7d7161c9ed96489c66364c4bfbf635929166843bba10d97d46b5a2e1f")
| STATS first_seen = MIN(@timestamp), files = VALUES(file.path), writers = VALUES(process.executable) BY host.name

CrowdStrike


// set the time picker to start at 2026-11-17 20:35 UTC
#event_simpleName=/Written$/
| test(@timestamp >= 1794947700000)
| case {
    TargetFileName=/[\\\/](agent_framework_meta\.pth|af_runtime_diag\.pth|af_runtime_diag\.py)$/i | match_on := "file name" ;
    TargetFileName=/agent_framework_meta[\\\/]_telemetry\.py$/i | match_on := "file name" ;
    in(field=SHA256HashData, values=["21f28e8517a10ffe431f8d68f5875c85eca4001ae6d118322b0a41873998eb5e", "39fa329f2a93f734b0bb8f5adb203ea3331d1ae479832a5015a54cb17aabd663", "c275ccbe520ef3c0f02dc6a35389e427f9f1b4e0b12e140cd7bf7179ce143f02", "325e7e9f0ec94e41ad1a1b7a3f18a6b8b5bffece2e2b97b8d3369eb967452f93", "54d885b7d7161c9ed96489c66364c4bfbf635929166843bba10d97d46b5a2e1f"]) | match_on := "hash" }
| groupBy([aid], function=[min(@timestamp, as=first_seen), collect([TargetFileName, match_on])])

Microsoft KQL


let hashes = dynamic(["21f28e8517a10ffe431f8d68f5875c85eca4001ae6d118322b0a41873998eb5e", "39fa329f2a93f734b0bb8f5adb203ea3331d1ae479832a5015a54cb17aabd663", "c275ccbe520ef3c0f02dc6a35389e427f9f1b4e0b12e140cd7bf7179ce143f02", "325e7e9f0ec94e41ad1a1b7a3f18a6b8b5bffece2e2b97b8d3369eb967452f93", "54d885b7d7161c9ed96489c66364c4bfbf635929166843bba10d97d46b5a2e1f"]);
DeviceFileEvents
| where Timestamp >= datetime(2026-11-17T20:35:00Z)
| where FileName in~ ("agent_framework_meta.pth", "af_runtime_diag.pth", "af_runtime_diag.py")
    or FolderPath matches regex @"(?i)agent_framework_meta[\\/]_telemetry\.py$"
    or SHA256 in (hashes)
| summarize FirstSeen = min(Timestamp), Files = make_set(FolderPath, 20), Writers = make_set(InitiatingProcessFileName, 10) by DeviceName

Hunt 2: egress to the exfil endpoint


This hunt finds DNS, proxy or EDR network events to webhook[.]site, ranked by the incident UUID path, the stealer user agents, then Python lookups. Per Wiz, HTTP 200 means the data was accepted; 410 or 429 suggests the free-tier cap rejected it.


Field mapping: Splunk uses Sysmon EID 22 and CIM proxy fields, Elastic adds YOUR_PROXY_INDEX, Falcon sees DNS only, and KQL adds CommonSecurityLog; path, user agent and status need proxy logs.


False positives: webhook[.]site is a public service developers use legitimately; the UUID path is the incident signal.


Splunk


earliest=1794947700 latest=now ((index=YOUR_SYSMON_INDEX EventCode=22 QueryName="webhook.site") OR (index=YOUR_PROXY_INDEX ("webhook.site" OR "runtime-diagnostics/1")))
| eval proc=lower(replace(coalesce(Image, ""), "^.*[\\\\/]", "")), seen=lower(coalesce(url, "")." ".coalesce(http_user_agent, "")), client=coalesce(src, host)
| eval priority=case(match(seen, "d381fd80-ec62-42ad-8f5c-d1b15103c9bb"), "1 incident path", match(seen, "runtime-diagnostics/1"), "2 stealer user agent", match(proc, "^python[0-9.]*w?([.]exe)?$"), "3 python lookup", true(), "4 webhook.site, other")
| stats count AS events values(status) AS http_status values(proc) AS processes min(_time) AS first_seen BY client priority
| sort priority
| convert ctime(first_seen)

Elastic


FROM logs-endpoint.events.network-*, YOUR_PROXY_INDEX
| WHERE @timestamp >= TO_DATETIME("2026-11-17T20:35:00Z")
| EVAL seen = TO_LOWER(CONCAT(COALESCE(dns.question.name, ""), " ", COALESCE(destination.domain, ""), " ", COALESCE(url.original, ""), " ", COALESCE(user_agent.original, "")))
| WHERE seen RLIKE ".*(webhook[.]site|runtime-diagnostics/1).*"
| EVAL proc = TO_LOWER(COALESCE(process.name, "")), client = CASE(STARTS_WITH(COALESCE(event.dataset, ""), "endpoint."), host.name, COALESCE(TO_STRING(source.ip), host.name))
| EVAL priority = CASE(seen RLIKE ".*d381fd80-ec62-42ad-8f5c-d1b15103c9bb.*", "1 incident path", seen RLIKE ".*runtime-diagnostics/1.*", "2 stealer user agent", proc RLIKE "python[0-9.]*w?([.]exe)?", "3 python lookup", "4 webhook.site, other")
| STATS events = COUNT(*), http_status = VALUES(http.response.status_code), processes = VALUES(proc), first_seen = MIN(@timestamp) BY client, priority
| SORT priority

CrowdStrike


// set the time picker to start at 2026-11-17 20:35 UTC
#event_simpleName=DnsRequest DomainName=/(^|\.)webhook\.site$/i
| test(@timestamp >= 1794947700000)
| groupBy([aid, ContextProcessId], function=[count(as=lookups), min(@timestamp, as=first_seen), collect([DomainName])])

Microsoft KQL


// CommonSecurityLog needs Sentinel; isfuzzy skips it if absent. EventOutcome holds HTTP status only if your proxy maps it there.
union isfuzzy=true
    (DeviceNetworkEvents
    | where Timestamp >= datetime(2026-11-17T20:35:00Z)
    | where RemoteUrl has "webhook.site"
    | extend Client = DeviceName, Proc = tolower(InitiatingProcessFileName), Seen = tolower(RemoteUrl), Status = ""),
    (CommonSecurityLog
    | where TimeGenerated >= datetime(2026-11-17T20:35:00Z)
    | where DestinationHostName has "webhook.site" or RequestURL has "webhook.site" or RequestClientApplication has "runtime-diagnostics/1"
    | extend Timestamp = TimeGenerated, Client = SourceIP, Proc = "", Seen = tolower(strcat(DestinationHostName, " ", RequestURL, " ", RequestClientApplication)), Status = tostring(EventOutcome))
| extend Priority = case(Seen has "d381fd80-ec62-42ad-8f5c-d1b15103c9bb", "1 incident path", Seen has "runtime-diagnostics/1", "2 stealer user agent", Proc matches regex @"^python[0-9.]*w?(\.exe)?$", "3 python lookup", "4 webhook.site, other")
| summarize Events = count(), HttpStatus = make_set(Status, 10), Processes = make_set(Proc, 10), FirstSeen = min(Timestamp) by Client, Priority
| order by Priority asc

Hunt 3: Python requesting cloud identity tokens


This hunt flags Python connecting to IMDS at 169.254.169.254, or your App Service identity endpoint, ten or more times in five minutes, our threshold, since the stealer asks for 12 resources. On build agents, any such call after a pip install deserves a look.


Field mapping: Falcon network events carry no process name, so CrowdStrike reports every process; set YOUR_IDENTITY_ENDPOINT_IP or delete it.


False positives: the Azure SDK calls IMDS from Python constantly on Azure, and other clouds share the address; look for a new process tree or a webhook[.]site lookup nearby.


Splunk


index=YOUR_SYSMON_INDEX EventCode=3 earliest=1794947700 latest=now (DestinationIp="169.254.169.254" OR DestinationIp="YOUR_IDENTITY_ENDPOINT_IP")
| eval proc=lower(replace(Image, "^.*[\\\\/]", ""))
| where match(proc, "^python[0-9.]*w?([.]exe)?$")
| bin _time span=5m
| stats count AS connections values(DestinationIp) AS endpoints values(Image) AS images BY _time host ProcessId
| where connections>=10
| sort - connections

Elastic


FROM logs-endpoint.events.network-*
| WHERE @timestamp >= TO_DATETIME("2026-11-17T20:35:00Z")
| WHERE TO_STRING(destination.ip) IN ("169.254.169.254", "YOUR_IDENTITY_ENDPOINT_IP")
| WHERE TO_LOWER(process.name) RLIKE "python[0-9.]*w?([.]exe)?"
| EVAL window = DATE_TRUNC(5 minutes, @timestamp)
| STATS connections = COUNT(*), endpoints = VALUES(destination.ip), images = VALUES(process.executable) BY window, host.name, process.pid
| WHERE connections >= 10
| SORT connections DESC

CrowdStrike


// set the time picker to start at 2026-11-17 20:35 UTC
#event_simpleName=NetworkConnectIP4
| in(field=RemoteAddressIP4, values=["169.254.169.254", "YOUR_IDENTITY_ENDPOINT_IP"])
| test(@timestamp >= 1794947700000)
| window := @timestamp - (@timestamp % 300000)
| groupBy([aid, ContextProcessId, window], function=[count(as=connections), collect([RemoteAddressIP4, RPort])])
| test(connections >= 10)
| formatTime("%Y-%m-%d %H:%M", field=window, as=window_utc, timezone="UTC")

Microsoft KQL


DeviceNetworkEvents
| where Timestamp >= datetime(2026-11-17T20:35:00Z)
| where RemoteIP in ("169.254.169.254", "YOUR_IDENTITY_ENDPOINT_IP")
| where InitiatingProcessFileName matches regex @"(?i)^python[0-9.]*w?(\.exe)?$"
| summarize Connections = count(), Urls = make_set(RemoteUrl, 20), CommandLines = make_set(InitiatingProcessCommandLine, 5) by bin(Timestamp, 5m), DeviceName, InitiatingProcessId
| where Connections >= 10
| order by Connections desc

Hunt 4: installs of a bad version


This hunt finds installer command lines pinning 1.26.1 or 1.26.2, unpinned agent-framework installs from 1:35 to 2:17 PM MST on November 17 (our bound), and agent_framework-1.26.1.dist-info or agent_framework-1.26.2.dist-info folders, names we infer from standard Python packaging. Also grep lockfiles, CI logs and image layers.


Field mapping: Splunk, Elastic and KQL read process and file events together; Falcon reads ProcessRollup2 and file-written events.


False positives: an unpinned install in the window may have resolved 1.26.0 from a mirror; check the lockfile.


Splunk


index=YOUR_SYSMON_INDEX (EventCode=1 OR EventCode=11) earliest=1794947700 latest=now
| eval cl=lower(coalesce(CommandLine, "")), path=lower(coalesce(TargetFilename, ""))
| eval installer=if(match(cl, "(pip3?|uv|poetry|pipenv).*(install|add|sync)"), 1, 0)
| eval finding=case(match(path, "agent_framework-1[.]26[.][12][.]dist-info"), "bad version metadata (inferred name)", installer=1 AND match(cl, "agent[-_]framework(\\[[^\\]]*\\])? *== *1[.]26[.][12]([^0-9a-z.]|$)"), "pinned bad version", installer=1 AND match(cl, "agent[-_]framework([^-_a-z0-9=.]|$)") AND _time<1794950220, "unpinned install in window", true(), null())
| where isnotnull(finding)
| stats min(_time) AS first_seen values(CommandLine) AS commands values(TargetFilename) AS files BY host finding
| convert ctime(first_seen)

Elastic


FROM logs-endpoint.events.*
| WHERE @timestamp >= TO_DATETIME("2026-11-17T20:35:00Z")
| EVAL cl = TO_LOWER(COALESCE(process.command_line, "")), path = TO_LOWER(COALESCE(file.path, ""))
| EVAL installer = cl RLIKE ".*(pip3?|uv|poetry|pipenv).*(install|add|sync).*"
| EVAL finding = CASE(path RLIKE ".*agent_framework-1[.]26[.][12][.]dist-info.*", "bad version metadata (inferred name)", installer AND cl RLIKE """.*agent[-_]framework(\[[^\]]*\])? *== *1[.]26[.][12]([^0-9a-z.].*)?""", "pinned bad version", installer AND cl RLIKE ".*agent[-_]framework([^-_a-z0-9=.].*)?" AND @timestamp < TO_DATETIME("2026-11-17T21:17:00Z"), "unpinned install in window", NULL)
| WHERE finding IS NOT NULL
| STATS first_seen = MIN(@timestamp), commands = VALUES(process.command_line), files = VALUES(file.path) BY host.name, finding

CrowdStrike


// set the time picker to start at 2026-11-17 20:35 UTC
#event_simpleName=/^ProcessRollup2$|Written$/
| test(@timestamp >= 1794947700000)
| case {
    TargetFileName=/agent_framework-1\.26\.[12]\.dist-info/i | finding := "bad version metadata (inferred name)" ;
    CommandLine=/(pip3?|uv|poetry|pipenv).*(install|add|sync).*agent[-_]framework(\[[^\]]*\])? *== *1\.26\.[12]([^0-9a-z.]|$)/i | finding := "pinned bad version" ;
    CommandLine=/(pip3?|uv|poetry|pipenv).*(install|add|sync).*agent[-_]framework([^-_a-z0-9=.]|$)/i | test(@timestamp < 1794950220000) | finding := "unpinned install in window" }
| groupBy([aid, finding], function=[min(@timestamp, as=first_seen), collect([CommandLine, TargetFileName])])

Microsoft KQL


let installer = @"(?i)(pip3?|uv|poetry|pipenv).*(install|add|sync)";
let pinned = @"(?i)agent[-_]framework(\[[^\]]*\])? *== *1\.26\.[12]([^0-9a-z.]|$)";
let unpinned = @"(?i)agent[-_]framework([^-_a-z0-9=.]|$)";
union
    (DeviceProcessEvents
    | where Timestamp >= datetime(2026-11-17T20:35:00Z)
    | where ProcessCommandLine matches regex installer
    | extend Finding = case(ProcessCommandLine matches regex pinned, "pinned bad version", ProcessCommandLine matches regex unpinned and Timestamp < datetime(2026-11-17T21:17:00Z), "unpinned install in window", ""), Item = ProcessCommandLine),
    (DeviceFileEvents
    | where Timestamp >= datetime(2026-11-17T20:35:00Z)
    | where FolderPath matches regex @"(?i)agent_framework-1\.26\.[12]\.dist-info"
    | extend Finding = "bad version metadata (inferred name)", Item = FolderPath)
| where isnotempty(Finding)
| summarize FirstSeen = min(Timestamp), Items = make_set(Item, 20) by DeviceName, Finding

Hunt 5: environ scraping, in prose


In our judgment this stays prose: catching Python reading /proc/<pid>/environ for many PIDs needs file-open telemetry that Sysmon and Defender do not record by default. Process monitors, debuggers and APM agents read those files too.


Indicators from GHSA, Wiz, Elastic and StepSecurity


Type

Indicator

Source description

Package version

agent-framework==1.26.1

Malicious release, wheel only (GHSA, all)

Package version

agent-framework==1.26.2

Malicious release, wheel only (GHSA, all)

SHA256

d27fa34414e6201d5e03e559ef634f020057554d7b3f4898dd5d7cd3e989e110

agent_framework-1.26.1-py3-none-any.whl (GHSA, Wiz, Elastic, StepSecurity)

SHA256

3d20a8bc91351a9a16b6db243b848ceca0206b7a8623b02d2af553a9c9f7e0a9

agent_framework-1.26.2-py3-none-any.whl (GHSA, Wiz, Elastic, StepSecurity)

SHA256

21f28e8517a10ffe431f8d68f5875c85eca4001ae6d118322b0a41873998eb5e

agent_framework_meta.pth, 1.26.1 (Elastic, StepSecurity)

SHA256

39fa329f2a93f734b0bb8f5adb203ea3331d1ae479832a5015a54cb17aabd663

agent_framework_meta/_telemetry.py, 1.26.1 (Elastic, StepSecurity)

SHA1

0a013e4724c4437cf9b177def1d988113e167539

agent_framework_meta/_telemetry.py, 1.26.1 (Wiz)

SHA256

c275ccbe520ef3c0f02dc6a35389e427f9f1b4e0b12e140cd7bf7179ce143f02

agent_framework_meta/__init__.py, modified, 1.26.1 (Elastic)

SHA256

325e7e9f0ec94e41ad1a1b7a3f18a6b8b5bffece2e2b97b8d3369eb967452f93

af_runtime_diag.pth, 1.26.2 (Elastic, StepSecurity, Wiz)

SHA256

54d885b7d7161c9ed96489c66364c4bfbf635929166843bba10d97d46b5a2e1f

af_runtime_diag.py, 1.26.2 (Elastic, StepSecurity, Wiz)

URL

hxxps://webhook[.]site/d381fd80-ec62-42ad-8f5c-d1b15103c9bb?t=telemetry

Exfil endpoint, HTTPS POST, application/octet-stream, both versions

User-Agent

af-runtime-diagnostics/1

Exfil request, 1.26.1

User-Agent

runtime-diagnostics/1

Exfil request and GitHub OIDC request, 1.26.2

Base64 string

aHR0cHM6Ly93ZWJob29rLnNpdGUvZDM4MWZkODAtZWM2Mi00MmFkLThmNWMtZDFiMTUxMDNjOWJi

Exfil URL as stored in the _ENC variable (Elastic)

Environment variable

_AF_TEL=1

Run-once marker set by the stealer


Reading the results before you escalate


Test 1 measures exposure, not compromise.


In our judgment, a Hunt 1 match or a Hunt 2 hit on the incident path means the host carried the stealer, so contain, rebuild and rotate. A verified Hunt 4 match is strong evidence of exposure. Hunt 3, or a DNS-only Hunt 2 hit, is a lead until another hunt hits that host.


One next step


If your clients run on Microsoft 365, start with a free Inception Foresight M365 Assessment.


bg-map-white.png

INCEPTION SECURITY™

A cybersecurity company with in depth knowledge of the threat landscape and security controls.

NAVIGATION

GET IN TOUCH

© 2025 All Rights Reserved by INCEPTION SECURITY™ .

bottom of page