SHA pinning is no longer enough: the warning every SME should read
GitHub Actions SHA pinning, the usual defense against supply chain attacks, now has a bypass. We analyze the Trivy case and what to do in your SME.
4 min read

In this article
Over the past few years, pinning each GitHub action to an exact commit using its SHA hash has become one of the textbook recommendations for hardening the software supply chain. The logic was simple: if the code you run cannot change without the hash changing too, an attacker cannot slip a malicious version past you by surprise. That trust has just taken a significant hit.
According to The Hacker News, attackers have found a way to circumvent SHA pinning. The case that illustrates the problem occurred in March 2026, when those behind the hijacking of Trivy, a widely used open-source security scanner, introduced malicious code that appeared to come from GitHub's official checkout tool. They even labeled it so that it would look credible at first glance. The detail matters: this was not a misconfiguration on the victim's side, but an attack designed to look legitimate within the workflow itself.

What exactly this bypass means
SHA pinning protects against the substitution of one tag or version for another, but it does not solve every problem. If the attacker manages to get malicious code executed in a context the workflow considers trusted, or if they manage to make the dependency chain include elements the hash does not cover, the protection weakens. In the Trivy case, the injected code impersonated an official GitHub action, which shows that identity spoofing within the actions ecosystem is a real vector.
For an SME, the takeaway is not "SHA pinning is useless," but "SHA pinning is not enough on its own." Many small teams have adopted this practice as their only measure and have relaxed other layers. That is the risk: believing that one specific control closes the door to the entire category of supply chain attacks.
Why this affects an SME that does not use Trivy
Although the specific incident centers on a security scanner, the pattern repeats in any organization that automates deployments with GitHub Actions, CI/CD pipelines, or third-party integrations. SMEs tend to rely on these tools because of their low cost and speed of adoption, and precisely for that reason they accumulate actions from different vendors without checking who maintains them or how they are updated.
The potential impact is high: access to private repositories, deployment secrets, cloud credentials and, in the worst case, the ability to publish tampered versions of your own software. Such an attack does not require you to be a big target; it is enough for the attacker to find a popular dependency in your workflow.
What we recommend the IT team do
The first step is to review the inventory of actions you use. Not all of them deserve the same level of trust, and many can be replaced by your own scripts or by native runner steps.
- Audit external actions: identify which ones come from third parties, who maintains them and how often they are updated. Remove those that add no clear value.
- Combine pinning with origin verification: the hash protects the content, but you should also review the source repository, the token permissions and the tags used in the workflows.
- Principle of least privilege: limit the permissions of the GitHub Actions token to the bare minimum and avoid long-lived secrets accessible from the workflow.
- Human review for sensitive changes: any modification to the pipeline should go through review, just like production code.
- Monitoring and alerts: watch for anomalous runs, unexpected access to repositories and changes in the actions you use.
This approach fits with what we have already argued in other analyses on the blog, such as the need to treat cybersecurity as an investment with a return and not as a one-off expense. It is also worth reviewing the security vendors that support you: if you hire penetration tests or managed services, apply the same criteria we describe in the 15 questions before choosing an AI pentesting provider.
The underlying lesson
The SHA pinning bypass in the Trivy case is a reminder of something we at ForgeNEX repeat to SMEs: security cannot be bought in a single piece. Every control has a scope, and a motivated attacker will look for the gap that falls outside it. The sensible response is not to abandon good practices, but to combine them, review them periodically and accept that the software supply chain is a live front.
If your team manages pipelines with GitHub Actions, this is a good moment to sit down for an hour, list the actions that run and ask yourself, one by one, what would happen if one of them stopped being trustworthy tomorrow. That question, more than any specific tool, is what makes the difference.
Source: The Hacker News. Analysis and adaptation: ForgeNEX.
Keep reading
- Cyberattack on the cold chain: the real risk for SMEs and supermarkets17 November 2026
- N-able fixes 17 critical flaws in N-central and warns of crypto miners17 November 2026
- Mior and Skyfall break trust in AMD SEV-SNP16 November 2026
- Check Point unpatched: TSGA backdoor and ESXi wiping15 November 2026
- UnrealIRCd: exploited flaw allows command injection on the server15 November 2026