Springfield, OH · Call (937) 319-1211 · Send us a message

WinGet supply chain risk: one poisoned package spreading through trusted Microsoft distribution to Windows endpoints

Researchers at Cycode, a penetration testing company, found a critical zero-click flaw in tooling that Microsoft moderators use to manage the Windows Package Manager (WinGet) catalog. One crafted pull request could have caused that tooling to send a moderator's GitHub access token to a server the attacker controlled. The attack needed no phishing, no malware, and no click or approval from the moderator. Details in this article come from analysis published by CSO Online.

WinGet is Microsoft's free, open-source command-line tool for finding, installing, upgrading, configuring, and removing applications on Windows. It runs on more than 1.4 billion active devices across Windows 10, Windows 11, and Windows Server 2025. Its software catalog lives in a public GitHub repository. Community members submit pull requests (proposed changes to that catalog), and a small group of Microsoft moderators reviews them.

That review step is why this flaw carries more weight than a typical bug. By default, WinGet on every Windows machine trusts what those moderators approve. If your IT team uses WinGet to deploy or update software, the packages you install inherit that trust. According to Cycode, a stolen moderator token could have been used to push backdoored installers to 14,000 exposed packages under an official Microsoft badge. The same token could also reach other Microsoft repositories the moderator had access to.

This issue has been categorized as malware in some threat tracking. The underlying problem is a supply chain and CI/CD weakness in how the repository's automation handled credentials. Malicious package delivery to your endpoints would have been the result of exploitation, and the flaw itself involved no malicious code.

Cycode reports no evidence that the flaw was exploited in the wild. Microsoft has patched the affected PowerShell tool so that moderator tokens are attached only to requests bound for authorized GitHub endpoints. Frank Dickson of Dickson Research called the episode a near miss, but "a very serious one." He noted that a tampered install would have appeared in your logs as an approved package from an approved source.

Inside the Attack Path: From Pull Request to Poisoned WinGet Manifests

The attacker controlled exactly one thing in this chain: the contents of a pull request. Every step after that ran on Microsoft's own automation. A submitted manifest set its InstallerURL field to a server the attacker owned, and that single value carried the attacker's input into a privileged context.

The first automated stage was Microsoft's Azure DevOps validation pipeline, which tries to fetch the installer at the listed URL. The attacker's server was configured to return an error on purpose. The pipeline then applied a validation error label to the pull request. The label caused no harm by itself, but it was the trigger the next stage listened for.

The second stage was the moderators' internal PowerShell triage tool. When a moderator runs this tracker in its intended mode, a continuous background loop, it watches for labeled pull requests. On seeing the validation error label, it ran a CheckInstaller routine that sent an HTTP HEAD request to the same InstallerURL to re-check the installer. That request went through an authenticated HTTP helper, a wrapper function built to attach credentials to outgoing requests and handle authorization errors. The helper added the moderator's GitHub Personal Access Token to every request and never checked the destination host.

The third stage required no further action from the attacker beyond reading their own web server logs. The HEAD request arrived with the moderator's Classic PAT in its headers. For your organization, this pattern means that an internal script holding a credential can send that credential anywhere an outside party can point it.

PowerShell's role is specific. The attacker never ran PowerShell code and never injected commands into the script. The vulnerable logic lived in Microsoft's PowerShell helper, and the C# version of the same tool, stored in the same directory, attached credentials safely. The flaw was a credential-scoping bug in a trusted script that processed untrusted input.

The fourth stage is what the stolen token allowed. The token carried the moderator's full GitHub identity, so its permissions matched the employee's account across GitHub. According to the researchers, an attacker holding it could:

  • Push malicious manifests and approve their own pull requests in the WinGet catalog
  • Insert backdoored installers into any of the 14,000 exposed packages, published under Microsoft's official identity
  • Read and write to every other Microsoft repository the moderator could access
  • Modify GitHub Actions workflows in those repositories to achieve remote code execution and exfiltrate corporate secrets

The downstream effect would land on endpoints. Any user or IT team running winget install or an upgrade would receive the altered package, and logs would record an approved package from an approved source. An organization deploying software through scripted WinGet rollouts would have installed the attacker's code across its fleet with no unusual entries to investigate.

Mapped to MITRE ATT&CK, the chain aligns with these techniques:

  • T1528 Steal Application Access Token: extraction of the moderator's PAT from the HEAD request
  • T1078 Valid Accounts: acting in GitHub with the moderator's legitimate identity
  • T1195.002 Compromise Software Supply Chain: altering manifests and installers distributed through the WinGet catalog
  • T1059.001 PowerShell: relevant as the execution context of the vulnerable helper, which the attacker abused indirectly and did not run directly

The source does not publish proof-of-concept payloads, server responses, indicators of compromise, or a disclosure timeline. It also does not describe how installer hashes in manifests would have been handled. Any technical claims beyond the steps above are outside what the researchers have released, and there is no evidence the flaw was exploited in the wild.

How a WinGet pull request exposed a moderator's GitHub token
1
Crafted manifest pull request
The attacker submits a manifest whose installer URL points to a server they control. This is the only input they supply. InstallerURL
2
Validation pipeline labels PR
The Azure DevOps validation pipeline fetches the installer, and the attacker's server returns an error. The pipeline applies a validation error label, which triggers the next stage. Azure DevOps validation pipeline
3
Triage tool re-checks URL
The moderator's PowerShell triage tool runs CheckInstaller against the labeled PR. Its authenticated HTTP helper attaches the moderator's GitHub PAT without checking the destination host. CheckInstaller: HTTP HEAD to InstallerURL
4
Token read from logs
The attacker reads the Classic PAT from their web server logs. The token carries the moderator's full GitHub identity, which allows pushing manifests, self-approving PRs, and inserting backdoored installers. High

Why a WinGet Supply Chain Compromise Matters to Enterprises Using Windows Package Manager

There is currently no evidence that anyone exploited this flaw before Microsoft patched it. Everything in this section describes what the exposed credential would have allowed, so it belongs in your risk planning as a near miss to study and learn from.

The token at stake was a full identity credential tied to a Microsoft employee's GitHub account. Whoever held it could act as that moderator: push manifests, approve their own pull requests, and place backdoored installers into the 14,000 packages the catalog exposes. Those changes would have carried official Microsoft standing, which WinGet installations trust by default.

If your organization uses WinGet for software deployment, the exposure follows wherever WinGet runs without a person checking the result. That typically includes:

  • Developer workstations, where engineers install tools through WinGet and also hold source code access, cloud credentials, and SSH keys.
  • Endpoint management platforms such as Intune, or similar tools, configured to call WinGet for application installs and updates.
  • Automated provisioning scripts that build new machines by pulling packages with no human review.

Frank Dickson of Dickson Research described the operational effect plainly. An IT team running a standard scripted rollout would have installed the attacker's code on every machine, and the logs would have shown an approved package from an approved source. For your security team, a tampered package arriving this way gives neither users nor analysts reviewing install records an obvious reason to question it.

Once malicious code runs on a developer machine, the follow-on risks are well understood. Attackers typically collect stored credentials, browser sessions, and access tokens, then use them for lateral movement (spreading from one compromised system to others on your network). Your incident response team would then need to work out which machines installed which package versions, and when. That work is slow when every install record looks legitimate, and it usually involves significant staff time, outside forensic help, and possible notification obligations if regulated or customer data was reachable.

The impact also extended past WinGet. The token reached every other Microsoft repository the moderator could access, including the ability to modify GitHub Actions workflows to achieve remote code execution and exfiltrate corporate secrets. Dickson noted this would have let an attacker take over build machinery to steal more secrets, which means other Microsoft projects your organization consumes could also have been affected.

This fits a recurring pattern. The npm and PyPI ecosystems have repeatedly dealt with malicious packages and compromised maintainer accounts, and CI/CD pipelines have been abused through leaked tokens that carried broader permissions than the job needed. Moriel Harush of Cycode summarized the logic: compromise a single maintainer and you reach everyone who trusts them. The WinGet case differs in scale because the credential belonged to a gatekeeper who reviews submissions for the whole catalog.

For leadership, the useful questions concern visibility and third-party trust:

  • Which of your endpoints, servers, and build agents install software from WinGet or other public registries, and through which tools?
  • Which of your own scripts and bots hold tokens, and what could each token do if it leaked?
  • Do your vendor risk reviews account for the package registries your suppliers depend on?
  • Could your team produce a list of every package version installed across your fleet during a given period?

Dickson observed that internal tools, bots, and automation often receive production-level keys with hobby-level review, and that observation applies to most enterprise automation, which is why these questions belong with your executives as well as your IT staff.

How the exposed WinGet moderator token could have been abused
1
Moderator token exposed
A full identity credential tied to a Microsoft employee's GitHub account would let its holder act as a catalog moderator.
2
Self-approved manifest changes
The holder could push manifests and approve their own pull requests, placing backdoored installers into catalog packages.
3
Trusted package distribution
Tampered packages would carry official Microsoft standing, which WinGet installations trust by default.
4
Unattended installs
Developer workstations, Intune deployments, and provisioning scripts would install the package without review, and logs would show an approved source.
5
Credential theft and lateral movement
Attackers typically collect stored credentials, browser sessions, and access tokens, then spread to other systems on the network.

Hardening WinGet Usage and CI/CD Workflows Against Pull Request Abuse

Your first step is to confirm the fix status and adjust where your effort goes. Microsoft has patched the flaw, which lived in the moderators' internal PowerShell triage tool. The corrected helper now attaches a token only when the request host is an authorized GitHub endpoint such as api.github.com, github.com, or raw.githubusercontent.com. Nothing needs installing on your endpoints for this issue, so your work centers on how your organization pulls packages from public registries.

These actions come first:

  • Inventory WinGet use. List every endpoint, deployment script, and scheduled task that calls WinGet. Run winget source list on representative machines to see which sources each one trusts.
  • Review recent installs on sensitive systems. Run winget list on servers, admin workstations, and finance machines. Compare the output against your approved software list and flag packages or installer sources nobody requested.
  • Find scripted rollouts. Any script that installs or upgrades packages unattended would have deployed a tampered package to every target machine, and the logs would have shown a normal, approved install.

Over the next few weeks, you can narrow what WinGet is allowed to fetch. The DesktopAppInstaller Group Policy templates include Enable App Installer Default Source and Enable App Installer Allowed Sources. Disable the default community source on production systems, and list only the sources you have approved. This follows Frank Dickson's advice that enterprises stop trusting public registries blindly.

Pin package versions in deployment scripts with winget install --exact --id and the --version flag, so an upgrade only happens after someone approves it. WinGet compares the downloaded installer against the hash in the manifest. A manifest changed by someone holding moderator rights would carry a matching hash for the tampered file, so record the hash yourself at approval time and verify it before broad rollout. For production deployments, a private REST source holding only vetted packages puts a person from your team between the public catalog and your machines.

Turn on PowerShell Script Block Logging under Administrative Templates, Windows Components, Windows PowerShell, and forward those events to your log platform. Watch for WinGet calls that reference unapproved sources or install packages outside a change window. Without that record, you would have no way to trace which machines received a given package version.

If your organization runs its own GitHub repositories, the WinGet case shows the risk directly: input from an outside pull request reached code that held a credential. Apply the same scrutiny to your own pipelines:

  • Avoid pull_request_target workflows that check out or run code from the pull request. That trigger runs with access to repository secrets and a write-capable token.
  • Set a top-level permissions: block that defaults GITHUB_TOKEN to contents: read, and set the repository's default workflow permissions to read-only.
  • Never place untrusted values such as pull request titles, branch names, or URLs directly inside PowerShell or shell run steps. Pass them through environment variables and validate them first.
  • Enable the Actions setting that requires approval before workflows run for first-time contributors.
  • Rotate any secret or token that a workflow could have exposed.

Cycode's broader guidance is to bind credentials to destinations. In practice, any wrapper that adds an authorization header should check the target host against an allowlist first. Replace classic PATs with fine-grained, short-lived tokens limited to one repository and the minimum permissions, so a leaked token exposes one project and leaves the employee's wider account untouched. Dickson recommends inventorying every script and bot that holds a token and recording two answers for each: what the key could do if stolen, and which hosts it is allowed to reach. Review those automations on the same schedule you use for staff access reviews.

Key Takeaway: Treat Package Manager Repositories as Part of Your Attack Surface

The WinGet case shows that a community-maintained repository is a delivery channel your endpoints already trust, and the automation that maintains it carries that same trust. When a contribution is mishandled at that layer, it reaches every downstream user who installs or updates from that source. Frank Dickson of Dickson Research described the broader pattern plainly: internal tools, bots, and automation get "production-level keys and hobby-level review."

The same pattern can exist in your own build systems and deployment scripts. Cycode's Moriel Harush pointed out that automation removes the person who would have clicked a malicious link, and it also removes the person who would have noticed something unusual. If your pipelines act on pull requests or pull packages with no human in the loop, they inherit that blind spot, and any credential they hold is only as safe as the least-checked input they process. Dickson's advice is to review your automations the way you review your people, asking what each key could do in the wrong hands and where it is allowed to go.

The single most important action is to control which WinGet sources your endpoints can install from and to audit your own CI/CD workflows for steps that run code or use credentials on pull requests from untrusted contributors. Whoever manages your Windows workstations and your code repositories can confirm both points for you. A security assessment is another reasonable next step: a 15-minute call followed by written findings on five areas, with security controls and remote access closest to this issue, alongside dark web exposure, phishing risk, and employee training readiness.

How a mishandled contribution reaches trusted endpoints
1
Untrusted pull request
A contributor submits a change to a community-maintained repository such as WinGet.
2
Automation processes it
Bots holding credentials act on the input with no human in the loop to notice anything unusual.
3
Trusted source publishes
The mishandled change enters a delivery channel that endpoints already trust.
4
Endpoints install or update
Every downstream user who installs or updates from that source receives the change.
5
Restrict sources and audit
Control which WinGet sources endpoints can install from. Audit CI/CD workflows that run code or use credentials on pull requests from untrusted contributors.

In This Article

The Monthly Briefing

One email a month on the security incidents that mattered to Ohio professional firms, explained in plain language, with one thing to do before the next issue.

No product pitches. Leave any time.

Latest Weekly Briefings