Skip to content

QryptoCon 2026 · Dec 9–10 · Expert sessions on PQC, PKI, & Certificate Management

Save Your Seat →

A Stolen Release Credential Just Turned an Official Microsoft Package into Malware 

Testing post-quantum authentication with Microsoft PKI

For about an hour on November 17, 2026, installing Microsoft’s official AI agent SDK from PyPI meant running a credential stealer. Nobody typosquatted the package name. This software supply chain attack came through Microsoft’s own signing and publishing path, using a credential that the release system trusted. 

Key Takeaways 

  • Two malicious versions of Microsoft’s agent-framework package (1.26.1 and 1.26.2) were published to PyPI on November 17, 2026 and were gone within about an hour of the first upload. The most recent safe version is 1.26.0. 
  • According to Wiz Research, 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 the package. 
  • ESRP’s IP filtering blocked the attacker’s first upload attempt from AWS. The attacker retried from Microsoft-owned IP space and got through, showing that a network control cannot, on its own, protect a credential that can be copied. 
  • The payload ran every time Python started, even if the package was never imported, and harvested environment secrets, credential files, and Azure and GitHub Actions identity tokens. 
  • The lesson for every software publisher: signing and release keys are only as trustworthy as where they live and who can use them. A key that can be copied off a build machine will eventually be copied. 

What happened to Microsoft’s agent-framework package 

An attacker published two credential-stealing releases of Microsoft’s agent-framework package to PyPI through a legitimate-looking release path. agent-framework is the Python umbrella package for Microsoft Agent Framework, an open-source toolkit for building and orchestrating AI agents. Wiz Research puts its volume at about 41,000 downloads a week. 

Time (UTC) Event 
Nov 12, 2026, 18:25 Legitimate version 1.26.0 published 
Nov 17, 2026, 20:35 Malicious version 1.26.1 published 
Nov 17, 2026, about 21:08 Malicious version 1.26.2 published 
Nov 17, 2026, about 21:30 Both malicious versions no longer available on PyPI 

The short window limited the damage, but it did not prevent it. A package that sees tens of thousands of weekly installs, many of them from automated CI pipelines, does not need a long exposure window to reach real environments. 

How the attacker got a trusted release path 

The attacker did not break PyPI. Wiz reports the attacker appears to have obtained a client certificate and its private key for ESRP, the internal Microsoft service that signs and publishes this package. With that credential, the upload looked like a normal Microsoft release. 

One detail deserves more attention than it has received. The attacker’s first publish attempt came from AWS and was rejected by ESRP’s IP filtering. A second attempt, from Microsoft-owned IP space, succeeded. The network control worked exactly as designed, and it still lost, because once the attacker found an approved network location, the certificate and key were all the authority they needed. How the credential was obtained has not yet been disclosed. 

Wiz also found that the attacker’s tooling identified itself as Cairn, an open-source AI penetration-testing framework, and that the attacker tested the stealer on their own machine before publishing. Automated, agent-driven tooling lowers the effort needed to turn one stolen credential into a working supply chain attack. 

What the malware did once installed 

The malicious versions dropped a .pth file into the Python site-packages directory. Python executes .pth files on every interpreter start, so the stealer ran whenever Python launched in that environment, whether or not any code imported agent-framework. According to OX Security, the malicious releases also pulled in the genuine agent-framework-core 1.26.0, so applications kept working and the compromise was easy to miss. 

The stealer focused on Azure, Azure DevOps, and CI environments. It collected: 

  • Environment variables whose names suggested secrets, such as TOKEN, SECRET, PASSWORD, KEY, AZURE, AWS, and GITHUB 
  • Secret-looking values from the environments of other running processes 
  • Credential files for the Azure CLI, npm, pip, git, Docker, and Hugging Face, plus Azure DevOps agent credentials and .env files 
  • Azure DevOps OIDC tokens and Azure managed-identity tokens for services including Azure Resource Manager, Microsoft Graph, Key Vault, and Storage 

Version 1.26.2 changed its trigger file names, so a search for the 1.26.1 indicators alone would miss it, and added theft of GitHub Actions OIDC tokens from workflows with id-token: write. Where an Entra ID federated credential trusts that workflow, such a token can be exchanged for Azure access without any stored secret. 

The attacker sent stolen data to a free-tier webhook.site URL, where at most 50 requests were captured. Wiz analyzed those requests and counted three unique cases of successful victim data exfiltration. That is a small number, but each one can include working cloud, CI, and registry credentials, and Wiz notes that stolen managed-identity and OIDC-exchanged tokens stay valid for up to 24 hours. 

Enterprise Code-Signing Solution

Get One solution for all your software code-signing cryptographic needs with our code-signing solution.

Why this software supply chain attack is so damaging 

An attack through a legitimate release path defeats the checks consumers rely on most. Developers trust the package name, the publisher, and the release channel. When all three are genuine, the malicious version inherits the reputation of every clean version before it. 

This is a closely related failure mode seen in earlier code signing incidents. When the MSI firmware signing keys were stolen in 2023, the risk was that attackers could push malware that looked identical to legitimate updates. A signature or a trusted publishing path proves who released an artifact. It does not prove the artifact is safe. That guarantee only holds while the key behind it is controlled. 

It is also not the first Python package from Microsoft to be hit this year. Wiz notes that the durabletask package was compromised earlier in 2026 after its PyPI token was stolen, although it has not linked the two incidents. The pattern is clear: attackers are going after whatever credential grants publishing authority. 

Our take: where release keys live decides whether they can be stolen 

Here is what we recommend to any organization that signs or publishes software, whether it ships open-source packages, firmware, or internal builds. 

  1. Make signing and release keys non-exportable: A private key stored as a file, or in a secret store that hands the key to a build agent, can be copied. A key generated and held inside a FIPS 140-3 validated hardware security module (HSM) can be used but never extracted. If an attacker compromises a build machine that only has permission to request signatures, they get a session, not a portable credential. Teams without on-premises hardware can get the same boundary through HSM-as-a-Service. 
  1. Bind credential use to identity and context, not only network location: IP allowlisting stopped the first attempt in this incident and failed on the second. Treat network controls as one signal among several, alongside the calling workload’s identity, the pipeline it runs in, and the change being released. 
  1. Prefer short-lived, narrowly scoped credentials, and scope the trust behind them: Long-lived certificates and tokens give attackers time. Short-lived OIDC credentials are better, but this payload specifically hunted for OIDC tokens, so the federated trust relationships that accept them need tight conditions on repository, branch, workflow, and environment. 
  1. Make the signing service check what it is asked to sign: Require build provenance, such as signed attestations that tie an artifact to a specific source commit and build pipeline, and refuse to sign or publish anything that did not come from the expected build. 
  1. Gate out-of-pattern releases with approvals: Two patch releases 33 minutes apart, five days after the previous release, is unusual. Policies that require multi-party (M-of-N) approval for releases outside the normal cadence or from an unexpected source turn a stolen credential into a request someone has to approve. 
  1. Log every signing operation and alert on anomalies: An immutable audit trail of who signed what, from where, and under which policy is what lets a team answer the hardest question after an incident: what else did this key sign? 
  1. Inventory every signing and release credential: You cannot protect keys you do not know exist. Service certificates, publishing tokens, and signing keys scattered across pipelines should be discovered and tracked like any other cryptographic asset, which is the job of a cryptographic inventory such as CBOM Secure. 
  1. Rehearse revocation before you need it: Know in advance how to revoke a release credential, pull affected versions, and notify consumers, so containment takes minutes rather than days. 

For a full walkthrough of these controls across the development lifecycle, see our guide to code signing best practices in the SDLC. 

If you installed agent-framework: what to do now 

Wiz recommends the following steps for any team that may have pulled the malicious versions: 

  1. Search lockfiles, CI logs, virtual environments, and container images for agent-framework 1.26.1 or 1.26.2, and pin to 1.26.0. 
  1. Look in site-packages for agent_framework_meta.pth and agent_framework_meta/_telemetry.py (1.26.1), or af_runtime_diag.pth and af_runtime_diag.py (1.26.2). Any Python process started in that environment ran the payload. 
  1. Search proxy and DNS logs for the webhook.site exfiltration URL listed in the Wiz advisory. 
  1. Rotate every secret that was present on affected hosts and runners, including Azure CLI sessions, Azure DevOps personal access tokens and service connections, and npm, PyPI, NuGet, Docker, Hugging Face, and git credentials. 
  1. Review sign-in and activity logs for managed identities and federated credentials reachable from affected systems, and for GitHub Actions workflows that installed 1.26.2 with id-token: write. 

As a longer-term habit, install dependencies with hash checking and consider a short delay before adopting brand-new releases of critical packages, so registry takedowns have time to happen before your pipelines pull a bad version. 

CBOM Secure

Gain complete visibility with continuous cryptographic discovery, automated inventory, and data-driven PQC remediation.

How Encryption Consulting can help 

Encryption Consulting helps software publishers move signing and release keys out of places where they can be copied, and put policy in front of every signature. 

  • CodeSign Secure: centralized code signing with private keys held in FIPS-validated HSMs that never leave the device, signing built into CI/CD pipelines, and RBAC, M-of-N approvals and an audit trail of every signature. 
  • HSM-as-a-Service: hosted HSM protection for signing and release keys, for teams that do not want to run hardware on premises. 
  • CBOM Secure: discovery and inventory of cryptographic assets, so the service certificates, signing keys and other release credentials spread across your pipelines are found and tracked. 
  • Encryption Advisory and HSM Services: an assessment of your current signing and release pipeline, covering where keys live, who and what can use them, which controls sit in front of each signature, and how quickly you could revoke a compromised credential. 

Conclusion 

The agent-framework incident did not require breaking PyPI. Based on what Wiz has reported so far, it required a credential that could authorize a release, held somewhere an attacker could take it, plus a network location the release service already trusted. With both in hand, the attacker’s upload looked like a Microsoft release. Every publisher has some version of that credential. The question worth asking this week is simple: if someone copied it tonight, what would stop them? 

If the honest answer is “an IP allowlist,” it is time to move your signing keys, and the credentials that unlock them, into hardware and put policy in front of every signature. 

See how CodeSign Secure keeps your signing keys out of attackers’ hands. Book a demo or talk to our code signing experts about assessing your current release pipeline. 

Frequently Asked Questions 

Which versions of Microsoft agent-framework were malicious? 

Versions 1.26.1 and 1.26.2 of the agent-framework package on PyPI, both published on November 17, 2026 and removed by about 21:30 UTC the same day. Wiz Research identifies 1.26.0 as the most recent safe version. Teams should check lockfiles, CI logs, virtual environments, and container images for either malicious version and pin to 1.26.0. 

How did the attacker publish through Microsoft’s release process? 

Wiz Research reports the attacker appears to have compromised a client certificate and private key for Microsoft ESRP (Engineering System Release Pipeline), the internal service that signs and publishes the package. A first attempt from AWS was blocked by ESRP’s IP filtering, and a second attempt from Microsoft-owned IP space succeeded. How the credential was obtained has not been disclosed. 

Why didn’t signing stop this attack? 

A signature or trusted publishing path proves who released a package, not whether its content is safe. When an attacker holds the credential the release system trusts, malicious code inherits the same authority as a legitimate build. Signing protects users only when the key behind it cannot be copied and every use of it is checked against policy. 

How should software publishers protect signing and release keys? 

Generate and keep private keys in a FIPS 140-3 validated HSM so they cannot be exported, grant access through short-lived, narrowly scoped identities, require approvals for out-of-pattern releases, and log every signing operation. Maintain an inventory of every release credential and a tested revocation plan so a compromise can be contained in minutes rather than days.