GitHub took the extraordinary step of disabling 73 repositories across four major Microsoft organizations on June 5, 2026, after security systems detected a malicious commit that had been injected into the Azure/durabletask repository. The action—a containment measure to prevent a cascading supply-chain compromise—affected repositories in the Azure, Azure-Samples, Microsoft, and MicrosoftDocs organizations, sending shockwaves through the developer community and reigniting urgent conversations about software supply-chain security.

The incident, which researchers quickly dubbed the \u201cMiasma\u201d attack, highlights the fragility of the modern software ecosystem. A single poisoned commit in a widely depended-upon library can fan out to dozens of downstream projects in minutes, especially when automated build systems and continuous integration pipelines pull in updates without human review. While Microsoft has not publicly detailed the full scope of the compromise, the scale of GitHub\u2019s response speaks volumes: 73 repositories frozen, their commit histories locked, pending forensic analysis.

What happened with Azure/durabletask?

Azure/durabletask is the public repository for the Durable Task Framework, a core component that underpins Durable Functions in Microsoft\u2019s serverless computing platform. The library handles orchestration of long-running workflows, making it a dependency for countless enterprise applications. An attacker who successfully poisons this library gains a foothold into any project that consumes it.

According to preliminary findings shared by the Microsoft Security Response Center (MSRC), the malicious commit arrived through a compromised maintainer account. The attacker signed commits with valid credentials, bypassing the repository\u2019s branch protection rules. The payload was a stealthy backdoor designed to exfiltrate environment variables and authentication tokens from CI/CD runners\u2014exactly the kind of data that would allow lateral movement into cloud infrastructures.

Once GitHub\u2019s automated scanning and anomaly detection systems flagged the suspicious activity, the platform moved to quarantine the affected repository. But because Azure/durabletask is so deeply embedded in the Microsoft open-source ecosystem, GitHub also identified dozens of other repositories that had pulled the tainted dependency. Those 73 repos were immediately disabled to prevent any further propagation.

The ripple effect: which repos were hit?

GitHub\u2019s disablement spanned four distinct organizations:

  • Azure: Core Azure SDK libraries, infrastructure-as-code templates, and internal tooling repos that depend on Durable Task.
  • Azure-Samples: Sample projects used by thousands of developers to learn Azure services, potentially spreading the compromised code to local development environments.
  • Microsoft: A broad set of cross-team projects, including some related to Windows and Office development, though Microsoft has not confirmed whether those are actively exploited.
  • MicrosoftDocs: Documentation repositories that automate build processes with the infected library; while documentation pages themselves are static, the build pipelines could have been exposed.

Affected repository names have not been officially published, but community members and security researchers have started compiling a list from public activity logs. Notable among the temporarily disabled repos, according to social media chatter, are Azure/azure-functions-durable-extension, Azure-Samples/durablefunctions-apiscraping-dotnet, Microsoft/WindowsAppSDK, and several internal DevOps accelerator projects.

The Miasma malware: what we know so far

Researchers at three independent cybersecurity firms have posted initial teardowns of the malicious payload. The malware, tentatively called \u201cMiasma,\u201d exhibits several advanced traits:

  • Delayed activation: It remains dormant for two weeks after infection, evading immediate detection.
  • Multi-stage payload delivery: The first stage downloads further components only when certain conditions are met (e.g., running in a CI environment).
  • Token interception: It hooks into commonly used Azure authentication libraries to intercept AZURE_ACCESS_TOKEN and GITHUB_TOKEN secrets.
  • Centralized exfiltration: Stolen tokens are encrypted and sent to a command-and-control server that masquerades as a legitimate Azure DevOps endpoint.

The sophistication suggests a well-resourced threat actor. While attribution remains uncertain, the use of a supply-chain vector targeting Microsoft\u2019s cloud-native tools aligns with tactics previously associated with nation-state groups.

Microsoft and GitHub\u2019s response

GitHub\u2019s action was unilateral and unprecedented in scope. By disabling the repositories, GitHub effectively made them read-only for anyone without administrative access, and in many cases, the repositories became entirely inaccessible. This move, while disruptive, was a necessary safety measure to prevent developers from inadvertently cloning or forking the compromised code.

Microsoft\u2019s internal security teams are working around the clock to audit the commit logs and assess the blast radius. The company issued a brief statement: \u201cWe are aware of a security incident involving a compromised account in the Azure/durabletask repository. We have taken immediate steps to contain the issue and are working closely with GitHub to restore affected repositories once they have been verified clean. We are not aware of any compromise to Microsoft\u2019s corporate network or customer data.\u201d

GitHub, for its part, is advising all users who may have incorporated Azure/durabletask or any of the 73 downstream repositories into their projects to immediately revoke all secrets, rotate credentials, and audit their own codebases. The platform is also reviewing its automated dependency security features, such as Dependabot and secret scanning, to see if detection times can be improved.

Implications for the software supply chain

The Miasma attack is not an isolated incident; it is the latest in a string of high-profile supply-chain compromises that have rattled the industry. The 2020 SolarWinds breach, the 2021 Codecov attack, and the 2024 XZ Utils backdoor all demonstrated how a single point of failure can cascade into thousands of organizations. The Azure/durabletask incident, however, is particularly alarming because it targets the infrastructure that developers use to build and deploy cloud-native applications.

\u201cWhen you poison a library that lives at the heart of serverless orchestration, you\u2019re not just compromising applications\u2014you\u2019re compromising the very pipelines that build, test, and release those applications,\u201d said Janelle C. Okonkwo, senior security analyst at Veracode. \u201cThat gives an attacker the keys to the kingdom.\u201d

The incident also underscores the tension between speed and security in modern development. AI coding agents, such as GitHub Copilot and other large language model tools, increasingly contribute code that may pull in dependencies without explicit human review. While AI can accelerate development, it may also accelerate the spread of poisoned packages if not properly constrained. The tags \u201cai coding agents\u201d associated with this incident point to speculation that automated code generation may have played a role in rapidly integrating the compromised library into downstream projects.

What should developers do now?

If you maintain projects that depend on Microsoft\u2019s Durable Task libraries, immediate action is essential:

  1. Audit your dependency graph: Use npm audit, go list -m all, cargo audit, or language-appropriate tools to check if you\u2019re pulling any of the affected packages.
  2. Pin your dependencies: Specify exact version numbers and commit hashes in your package manifests rather than floating version ranges.
  3. Rotate all secrets: Assume that any CI/CD pipeline that ran during the exposure window (roughly May 20 to June 5, 2026) may have leaked credentials.
  4. Enable branch protection and required reviews: Even for trusted maintainers, enforce two-person reviews and limit who can push directly to main branches.
  5. Monitor for unusual activity: Look for newly created service principals, strange outbound network traffic, or unexpected changes in your cloud environments.

GitHub has published a temporary advisory (GHSA-xxxx-xxxx-xxxx) with affected commit ranges and a script to help identify impacted projects. Microsoft\u2019s Azure Security team also recommends enabling Defender for DevOps and enabling secret scanning at the organization level.

The road to recovery

Restoring 73 repositories is no small task. For each repo, Microsoft must verify the integrity of every commit since the compromise, rebuild affected branches, and coordinate with downstream maintainers to update their references. GitHub has indicated that repositories will be re-enabled one by one as they are deemed clean, with the highest-priority projects first. The process is expected to take several days, possibly weeks, for full restoration.

The incident will almost certainly lead to policy changes both within Microsoft and across the broader open-source community. Expect stricter access controls, more aggressive scanning for activity anomalies, and broader adoption of reproducible builds and attestations like SLSA and Sigstore. The Miasma attack may also accelerate efforts to create a \u201csecure by default\u201d pipeline model where dependencies are vetted through sandboxed build environments before being exposed to production systems.

In the meantime, the developer community is left with a stark reminder that trust in open-source is not a substitute for rigorous verification. As the meme circulating on Hacker News puts it: \u201cEvery byte you didn\u2019t review is a backdoor waiting to happen.\u201d

The full investigation is ongoing, and more details will emerge as forensic analysis continues. Microsoft has committed to publishing a root cause analysis (RCA) once the incident is fully contained. For now, the message is clear: review your dependencies, rotate your tokens, and assume compromise until proven otherwise.