Enterprise Cybersecurity IntelligenceThursday

An enterprise cybersecurity intelligence company.For security and technology leaders.

Security.io Intelligence

What changed, why it matters,
and how it evolved.

Supply Chain · Executive briefing

Poisoned Microsoft Agent Framework releases turn rollback into credential containment

Two malicious releases of Microsoft’s official agent-framework package executed on every Python start and harvested cloud, CI/CD and developer secrets. Removal of the package does not close the credential exposure.

Supply ChainAI SecurityIdentity
Why it is in today’s brief

The malicious releases appeared on November 17, but the November 18 GitHub advisory and Wiz analysis materially changed the decision by confirming exact artefacts, credential targets and successful victim-data exfiltration. It warrants second position because a legitimate Microsoft package reached build environments with cloud identities, requiring secret containment and image rebuilding rather than a simple dependency rollback.

Read first

The November 18 GitHub advisory confirmed that agent-framework 1.26.1 and 1.26.2 were malicious releases of Microsoft Agent Framework. Executable .pth files caused credential-stealing code to run whenever Python started, even when the framework was never imported.

Act now

Search lockfiles, caches, images and virtual environments for agent-framework 1.26.1 and 1.26.2.

Accountable owner

Head of Application Security with Cloud Identity, CI/CD Platform Engineering and affected product teams.

Decision horizon

Immediate: complete exposure discovery today and begin credential containment as soon as any affected installation is confirmed.

AssessmentHigh confidence
Emerging riskMicrosoft or PyPI confirmation of the publication root cause, additional malicious versions, or evidence that other projects shared the compromised publishing path.

What happened

On November 17, 2026, agent-framework 1.26.1 was published at 20:35 UTC, 1.26.2 followed at 21:08 UTC, and both were unavailable by about 21:30 UTC. On November 18, 2026, GitHub published GHSA-764m-3ppc-5m73 identifying both releases as malicious credential stealers. GitHub’s advisory lists agent-framework 1.26.1 and 1.26.2 as malicious; 1.26.0 and earlier are not affected.

Each malicious wheel added an executable .pth startup hook, causing the payload to run on every Python interpreter start without requiring an import of agent_framework. Published indicators include webhook[.]site/d381fd80-ec62-42ad-8f5c-d1b15103c9bb, user agents af-runtime-diagnostics/1 and runtime-diagnostics/1, and files agent_framework_meta.pth, agent_framework_meta/_telemetry.py, af_runtime_diag.pth and af_runtime_diag.py.

The malicious wheel SHA-256 hashes are d27fa34414e6201d5e03e559ef634f020057554d7b3f4898dd5d7cd3e989e110 for 1.26.1 and 3d20a8bc91351a9a16b6db243b848ceca0206b7a8623b02d2af553a9c9f7e0a9 for 1.26.2. The known-good agent-framework 1.26.0 wheel hash is 14267ec8e6929c139015f8ec918adc638a71c7656901413426bb30ab199b6d71. The stealer collected secret-bearing environment variables, other processes’ /proc/*/environ data, Azure and package-manager credential files, Azure managed-identity tokens, Azure DevOps tokens and, in 1.26.2, GitHub Actions OIDC tokens.

The affected framework was Microsoft Agent Framework’s agent-framework Python package. No underlying AI model was identified in the cited sources as part of the credential-stealing operation. The malicious wheels were configured with executable .pth startup hooks and a hard-coded webhook.site exfiltration endpoint. On each Python interpreter start, the hooks launched a helper that collected reachable secrets and posted compressed, encoded data to the endpoint. Attribution posture: The GitHub advisory does not attribute the malicious releases to a known actor or campaign.

Why this matters now

The package name and project were legitimate, so controls based only on publisher identity or name allowlisting were insufficient. The malicious wheels retained genuine framework dependencies and normal application behaviour while a Python startup hook ran separately. That makes ordinary application testing a weak assurance mechanism and shifts the decision toward artefact verification, runner isolation and identity review.

The stolen material could include Azure managed-identity tokens, Azure DevOps OIDC tokens, GitHub Actions OIDC tokens, package-registry credentials, Docker configuration, git credentials and other process environments. Build runners often aggregate access across repositories, registries and cloud subscriptions, so a brief package-installation window can create a substantially larger identity blast radius.

Wiz’s analysis found confirmed victim-data exfiltration among the requests retained by the public webhook service. Although the malicious releases were quickly quarantined, copies may remain in CI caches, internal package mirrors, container layers, developer virtual environments and reproducible-build artefacts. Exposure discovery must therefore look beyond current PyPI availability.

The decision for security leaders

Classify any confirmed installation as credential exposure, not merely malware removal. Because the payload ran at Python startup and scraped other processes, responders should scope all secrets present on the host, runner or container during the exposure window, including ephemeral workload identities and federated OIDC relationships.

Require engineering to search historical build evidence rather than current environments alone. Lockfiles, package-resolution logs, CI job output, image manifests, software bills of materials, caches and internal mirrors provide the evidence needed to identify short-lived installations that no longer appear in running workloads.

Use the incident to tighten software-supply-chain trust for privileged pipelines. Provenance, hash pinning, isolated build credentials, short-lived identity, restricted egress and mirror quarantine should be governed together; publisher identity by itself did not prevent a malicious wheel from appearing under the legitimate project.

Evidence of closure

  • Repository and build searches show no unresolved use of agent-framework 1.26.1 or 1.26.2.
  • Rebuilt runner and container attestations reference only verified clean package hashes.
  • Internal mirrors and caches return no malicious wheel hashes or affected versions.
  • Credential-rotation records cover every secret reachable from each affected environment.

The Security.io assessment

The compromise is confirmed at the package level, and the GitHub advisory provides high-confidence hashes, filenames, versions and network indicators. Wiz analysed 50 requests retained by the webhook service and assessed that seventeen requests represented three unique successful victim-data exfiltration cases. That establishes real data collection while leaving the total downstream exposure unresolved.

Wiz assessed that an ESRP client certificate and private key were abused, but Microsoft had not publicly confirmed the publication root cause in the cited sources. The root-cause distinction matters for future trust decisions: a compromised publishing credential, signing path or maintainer account creates different follow-up scope, but none changes the immediate need to treat affected environments as exposed.

Fast quarantine reduced the public availability window, yet cached and mirrored artefacts preserve risk after repository cleanup. The operational conclusion should remain open until organisations prove that malicious versions were absent or, where present, that runner rebuilds, identity review, secret rotation and downstream access analysis are complete.

Questions for the morning meeting

  • Can engineering identify every environment that resolved agent-framework 1.26.1 or 1.26.2?
  • Which managed identities, OIDC trusts and long-lived secrets were reachable from affected runners?
  • Can internal mirrors prove the malicious wheels have been purged?
  • Does package policy require provenance and hash verification for privileged build environments?

Related intelligence

Shared decision context