Microsoft Agent Framework PyPI Compromise Targets Tokens


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.nameCrowdStrike
// 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 ascHunt 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.nameCrowdStrike
// 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 DeviceNameHunt 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 priorityCrowdStrike
// 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 ascHunt 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 - connectionsElastic
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 DESCCrowdStrike
// 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 descHunt 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, findingCrowdStrike
// 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, FindingHunt 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.



