138% more reported CVEs per day in 2026 than last year.New: always-on Fixboxes. Vulnerable dependencies, fixed and verified.
← All vulnerabilities

Trivy supply chain attack: the poisoned scanner and how to check whether your builds are affected

On 19 March 2026 an attacker used stolen credentials to publish a malicious Trivy v0.69.4 release, force-push 76 of the 77 version tags of the aquasecurity/trivy-action GitHub Action to credential-stealing code, and replace all 7 tags of aquasecurity/setup-trivy. On 22 March malicious Trivy images 0.69.5 and 0.69.6 appeared on Docker Hub. The incident is tracked as CVE-2026-33634, and CISA added it to its Known Exploited Vulnerabilities catalog on 26 March. If any CI job ran an affected version during the exposure window, treat that job as compromised and rotate every secret it could read.

What makes this software supply chain attack stand out is the tool it hit. Trivy is a security scanner, and teams run it inside the pipelines that hold their publish tokens and cloud credentials, precisely to make those pipelines safer. The payload ran before the real scan, so the job still produced a normal-looking report. And the credentials it stole went further: five days later, malicious LiteLLM releases appeared on PyPI after what PyPI calls "an API token exposure from an exploited Trivy dependency."

What happened

When (UTC)What happened
Late February 2026According to Aqua Security, attackers exploited a misconfiguration in Trivy's GitHub Actions environment and extracted a privileged access token. Aqua disclosed the incident on 1 March and rotated credentials, but not all at once, which may have let the attacker keep access.
19 March, from about 17:43The attacker pushed a malicious v0.69.4 tag, which triggered Trivy's release pipeline, and force-pushed the trivy-action and setup-trivy tags to malicious commits.
19 March, 18:22 to about 21:42Trivy v0.69.4 was public on GitHub releases, GHCR, ECR Public, Docker Hub (as 0.69.4 and latest), the deb and rpm repositories and get.trivy.dev.
19 March 17:43 to 20 March 05:40trivy-action tags pointed to the infostealer, about 12 hours. The setup-trivy tags were malicious until about 21:44 on 19 March.
20 to 23 MarchAqua opened a public discussion on 20 March and published the advisory on 21 March; the CVE followed on 23 March.
22 March 15:43 to 23 March 01:40aquasec/trivy:0.69.5 and 0.69.6 were pushed straight to Docker Hub with separately compromised Docker Hub credentials, with no matching GitHub release. The same evening, internal Aqua repositories were published on GitHub as public repositories.
24 MarchMalicious litellm 1.82.7 and 1.82.8 were published to PyPI. The CVE record for CVE-2026-33634 lists them as affected, together with telnyx 4.87.1 and 4.87.2.
26 MarchCISA added CVE-2026-33634 to the KEV catalog.

Who did it. Aqua's investigation, with the incident response firm Sygnia, found that the malware calls itself "TeamPCP Cloud stealer" in a comment in its payload. Aqua describes TeamPCP, "also tracked as DeadCatx3, PCPcat, and ShellForce", as a documented cloud-native threat actor and says the self-labelling could be a false flag, but the technical overlap with earlier TeamPCP tooling makes the attribution plausible. In its 23 March update Aqua also noted that Wiz Research had reported a compromise of Checkmarx's kics-github-action, another security scanner action.

Who is affected

According to Aqua's advisory, you are affected if, during the exposure window, you used:

  • The Trivy binary or image at v0.69.4, or at latest while v0.69.4 was the latest, from GitHub, the deb or rpm repositories, GHCR, ECR Public or Docker Hub, or the Docker Hub images 0.69.5 and 0.69.6. Aqua's own Homebrew tap was compromised as part of the v0.69.4 release too.
  • aquasecurity/trivy-action by any tag from 0.0.1 to 0.34.2, with the version: latest input during the binary window, or pinned to a commit from before 9 April 2025.
  • aquasecurity/setup-trivy by any version that was not pinned to a commit SHA.

You are not affected if you used Trivy 0.69.3 or earlier, images referenced by digest, Trivy built from source, the official Homebrew formula (brew install trivy, which builds from source), trivy-action 0.35.0, or a trivy-action pin to a safe commit after 9 April 2025.

The SHA pin catch. A commit pin protects only the reference you pinned. According to the advisory, a trivy-action commit from before 9 April 2025, when pull request #456 was merged, was itself safe but did not pin what it called. A job that ran it between about 17:43 and 21:44 on 19 March got the malicious setup-trivy.

How it works

The advisory classifies the incident as embedded malicious code (CWE-506). Three separate paths delivered the same infostealer:

  • A hijacked release pipeline. The attacker pushed a commit (1885610c) that swapped the actions/checkout reference in Trivy's release workflow for an imposter commit (70379aad). That commit contained a composite action that downloaded malicious Go source files from a typosquatted domain. The attacker also added --skip=validate to GoReleaser to bypass binary validation, and tagged the commit v0.69.4. The malicious code never reached Trivy's main branch; it was fetched and built on the release runner.
  • Moved tags. Git tags are mutable. Force-pushing trivy-action's tags to new commits changed what every workflow referencing @0.28.0 or any other tag ran, without a single change in those workflows. The malicious entrypoint.sh ran the stealer before the real scan; setup-trivy's action.yaml got the same code as a "Setup environment" step.
  • Images pushed directly. The 0.69.5 and 0.69.6 images used the same command-and-control domain as v0.69.4 and were pushed to Docker Hub with separate credentials, so no GitHub release or tag ever existed for them.

In a CI job the stealer then:

  1. Read the runner's memory. It dumped the GitHub Actions Runner.Worker process memory through /proc/<pid>/mem. That gets every secret the job holds, including secrets never passed to the Trivy step and secrets that log masking would hide.
  2. Swept the disk. More than 50 paths for SSH keys, AWS, GCP and Azure credentials, Kubernetes tokens, Docker configs, .env files, database credentials and cryptocurrency wallets.
  3. Sent it out. It encrypted the data with AES-256-CBC and RSA-4096 and posted it to scan.aquasecurtiy.org, a typo of Aqua's domain, as tpcp.tar.gz. If that failed and the action's GitHub token input (INPUT_GITHUB_PAT) was set, it created a public repository named tpcp-docs in the victim's GitHub account and uploaded the data as a release asset.

Why 0.69.3 and 0.35.0 were safe. Aqua had turned on GitHub's immutable releases on 3 and 4 March, before those versions were published, so their tags could not be moved. The same protection now blocks restoring the old tags: Aqua deleted trivy-action tags 0.0.1 to 0.34.2 and republished them with a v prefix (@v0.34.0 instead of @0.34.0), and setup-trivy tags 0.2.0 to 0.2.5 were not restored.

How to check whether you are affected

  1. Find every reference to trivy-action, setup-trivy and Trivy itself, on every branch that ran CI in the window, not only the default branch. Include Dockerfiles and scripts that install Trivy or pull aquasec/trivy.
  2. Sort them by how they were pinned. A tag reference, version: latest or an unpinned setup-trivy is affected if it ran in the window. A commit SHA needs a look at the commit's date (see the SHA pin catch above). An image by digest is not affected.
  3. List the runs in the window. Every job that used an affected reference between 19 March 17:43 and 20 March 05:40 UTC, or pulled an affected image between 22 March 15:43 and 23 March 01:40 UTC, ran the stealer.
  4. Check images and binaries you kept. Compare the digests of any aquasec/trivy images in your registries, mirrors and runner caches with the list in the advisory. Aqua notes that the malicious artifacts "may linger in intermediary caches".
  5. Look for tpcp-docs repositories in your organization and in the personal accounts of anyone whose token a workflow could use.

Commands you can adapt. To find every reference on every remote branch:

git fetch --all --quiet
for ref in $(git for-each-ref --format='%(refname:short)' refs/remotes); do
  git grep -n -E 'aquasecurity/(trivy-action|setup-trivy)@|aquasec/trivy|get\.trivy\.dev|trivy_0\.69\.[4-6]' "$ref" \
    -- '.github/workflows/*' '.github/actions/*' '*Dockerfile*' '*.sh' '*.yml' '*.yaml'
done

To list the runs of one workflow in the window and the Trivy images on a machine (replace ORG/REPO and the workflow file):

gh run list --repo ORG/REPO --workflow security.yml --created '2026-03-19..2026-03-20' \
  --limit 1000 --json databaseId,headBranch,createdAt --jq '.[] | [.databaseId, .headBranch, .createdAt] | @tsv'
docker image ls --digests aquasec/trivy

To find exfiltration repositories in your organization (replace ORG):

gh repo list ORG --limit 1000 --json name,createdAt \
  --jq '.[] | select(.name | startswith("tpcp-docs")) | [.name, .createdAt] | @tsv'

Why the workflow file doesn't settle it

  • The workflow didn't change; the tag did. uses: aquasecurity/[email protected] reads the same before, during and after the attack. Only the commit it resolved to on 19 March tells you what ran.
  • Nested actions. trivy-action calls setup-trivy. A pinned outer action with an unpinned inner one is only as safe as the inner reference.
  • latest resolves at run time. version: latest, aquasec/trivy:latest and install scripts that fetch the newest release all got the malicious version during the window, and none of them leave a version in the repository.
  • Trivy outside the workflow. Dockerfiles, Makefiles and setup scripts that download Trivy bypass the workflow file entirely.
  • The logs may be gone. GitHub keeps Actions logs for 90 days by default, up to 400 days for private repositories. For a March 2026 run, the logs that would show which commit ran have usually been deleted. If you can't prove a job ran a safe commit, assume it ran the malicious one.

What you need is a record of which action commits and tool versions each build actually ran, kept per build. See are we affected? how to assess a new CVE across your builds.

How to fix it, and what to do if you can't patch yet

  1. If a job ran an affected version, treat it as compromised. Rotate every secret the job could read, not only the ones passed to Trivy: the stealer read the runner's memory. That includes personal access tokens, registry and package publish tokens, cloud keys and deploy keys. Aqua's own root cause was a rotation that wasn't atomic, so revoke everything in one go rather than over days.
  2. Move to safe versions. Aqua lists Trivy 0.69.2 and 0.69.3, trivy-action 0.35.0 and setup-trivy 0.2.6 as known safe; later releases came after the incident. If you need an older trivy-action, use the v-prefixed tag (@v0.34.0), since the unprefixed ones were deleted.
  3. Pin to full commit SHAs. Pin trivy-action to the commit of 0.35.0 or a later release, and reference Trivy images by digest.
  4. Remove the artifacts. Delete any Trivy 0.69.4 binaries and 0.69.4, 0.69.5 and 0.69.6 images from registries, mirrors, runner images and caches, and rebuild anything a compromised job produced.

Verify the fix

  1. No tag references remain. The search above finds no trivy-action or setup-trivy reference without a 40-character SHA, and no aquasec/trivy:latest.
  2. The binaries and images check out. The advisory shows how to check a Trivy binary or image with cosign verify-blob and cosign verify and confirm the signing time predates 19 March.
  3. The old credentials no longer work. Revoked tokens are gone from the provider, and cloud keys are deactivated, not just replaced.
  4. No tpcp-docs repositories exist in your organization or your developers' accounts.
  5. The next build is clean. Check the action commit and Trivy version it actually ran, not only the workflow file.

How to reduce the damage next time

  • Enforce SHA pinning. Since August 2025, GitHub's allowed actions policy can require actions to be pinned to a full commit SHA and can block specific actions or versions. GitHub's workflow lockfiles, generally available since 28 October 2026, record the commits of actions and their transitive dependencies, which covers nested actions like setup-trivy.
  • Give scan jobs no publish secrets. A scanner needs read access to the code and a registry login at most. Run it in a separate job from the steps that publish or deploy, and keep GITHUB_TOKEN read-only there. See GitHub Actions secrets: how they leak and how to lock them down and GitHub Actions security.
  • Turn on immutable releases for actions and tools you publish yourself; it is what kept Trivy 0.69.3 and trivy-action 0.35.0 clean.
  • Limit where builds can connect. A scan job needs the vulnerability database and your registry, not scan.aquasecurtiy.org. With an egress policy, the stealer's upload fails. It does not stop the fallback, which wrote to GitHub's own API, a host most builds legitimately use.

Check for compromise

From Aqua's advisory, which also lists the SHA-256 of every v0.69.4 artifact:

TypeIndicator
Networkscan.aquasecurtiy.org, 45.148.10.212; uploads with the header X-Filename: tpcp.tar.gz
GitHubA public repository with the prefix tpcp-docs in the victim's account, with a release tagged data-<timestamp>
Trivy commits1885610c (release workflow change) and the imposter actions/checkout commit 70379aad
Binarytrivy_0.69.4_Linux-64bit.tar.gz, SHA-256 385d498d18a3a7c67878ca7322716f9da25683eb1a4bf9e9592da0d5f2ab09f6
Images0.69.4 sha256:27f446230c60bbf0b70e008db798bd4f33b7826f9f76f756606f5417100beef3; 0.69.5 sha256:5aaa1d7cfa9ca4649d6ffad165435c519dc836fa6e21b729a2174ad10b057d2b; 0.69.6 sha256:425cd3e1a2846ac73944e891250377d2b03653e6f028833e30fc00c1abbc6d33

When to assume compromise. Aqua's advice is that if there is any possibility a compromised version ran in your environment, "all secrets accessible to affected pipelines must be treated as exposed and rotated immediately." Finding no tpcp-docs repository proves nothing: that was only the fallback, and the primary upload left no trace in your account.

Review what the credentials touched. For every rotated credential, check cloud, registry and GitHub audit logs from 19 March onwards for activity you can't explain, such as new tokens, new deploy keys, workflow changes and package releases you didn't make. The stolen tokens were used to publish packages elsewhere, as LiteLLM found.

What to tell your customers

If customers use your product and know you scan with Trivy, or if you publish software built in pipelines that ran it, they will ask whether your releases or credentials were exposed. Answer with what you checked and what you did:

We checked every CI job that ran Trivy, aquasecurity/trivy-action or aquasecurity/setup-trivy between 19 and 23 March 2026 against Aqua Security's advisory for CVE-2026-33634. [No job ran an affected version.] / [Jobs in [pipeline] ran an affected version on [date]. We rotated every credential those jobs could access, reviewed audit logs for misuse, and rebuilt [product] from a clean pipeline in [version]. We found [no evidence of misuse / the following: ...].] Our releases [were / were not] built by the affected jobs.

If you're still checking, say so and say when you'll answer. For templates for each outcome, see how to answer customers after a supply chain attack. If you're comparing scanners after this incident, see Trivy vs CRACI and Trivy alternatives.

How CRACI helps

CRACI runs your GitHub Actions jobs on its own runners (runs-on: craci) and records what each job actually used: every package it fetched, including packages restored from caches, and the GitHub Actions it ran, recorded as pkg:github components pinned to the commit used. That is the record this incident needed. A workflow that says [email protected] doesn't tell you which commit ran on 19 March; the job's record does, and so does its network trace of what the job connected to. Build history keeps every past build with its SBOM, so you can see which builds contained a component and when, within your retention period (180 days by default).

CRACI's egress policy limits where a job can connect, is validated before the job starts and fails closed, so a payload sending stolen secrets to a host the build doesn't need, such as scan.aquasecurtiy.org, is blocked, even for an attack nobody has seen before. Known malicious releases with a published CVE are flagged like any other vulnerability, and policy gates can block builds that contain them. CRACI doesn't detect malicious code by behavior or reputation, so a new compromise isn't flagged before an advisory exists. For the wider picture, see CI/CD security.

See the record of one of your own builds

Other incidents: all vulnerabilities, including the LiteLLM PyPI compromise that followed this one, the tj-actions/changed-files compromise of 2025 that used the same moved-tag technique, and the Shai-Hulud npm worm.

Sources and updates

Primary sources:

Updates:

  • 2026-11-16: First published.

Frequently asked questions

What was compromised in the Trivy supply chain attack?

On 19 March 2026 an attacker published a malicious Trivy v0.69.4 release, force-pushed 76 of the 77 version tags of aquasecurity/trivy-action and all 7 tags of aquasecurity/setup-trivy to credential-stealing code, and on 22 March pushed malicious Trivy images 0.69.5 and 0.69.6 to Docker Hub. It is tracked as CVE-2026-33634.

Is Trivy safe to use now?

Aqua Security removed the malicious artifacts and lists Trivy 0.69.2 and 0.69.3, trivy-action 0.35.0 and setup-trivy 0.2.6 as known safe; later releases came after the incident. Pin the actions to full commit SHAs, reference images by digest, and rotate any secret a job could read if it ran an affected version in the window.

Was I affected if I pinned trivy-action to a commit SHA?

Usually not, but check the commit. According to Aqua's advisory, a trivy-action commit from before 9 April 2025 still fetched setup-trivy by tag, so a job that ran it while setup-trivy was compromised got the malicious setup step anyway. Pins to a safe commit after that date were not affected.

Who was behind the Trivy attack?

Aqua Security says the malware calls itself "TeamPCP Cloud stealer" and that the technical overlap with earlier TeamPCP tooling makes that attribution plausible, while noting the self-labelling could be a false flag. The same campaign is linked to the malicious LiteLLM releases on PyPI five days later.

Is CVE-2026-33634 in the CISA KEV catalog?

Yes. CISA added CVE-2026-33634 to its Known Exploited Vulnerabilities catalog on 26 March 2026. GitHub, the CNA, scores it 9.4 under CVSS 4.0; NVD scores it 8.8 under CVSS 3.1.

How do I know whether secrets were stolen?

Look for a public repository whose name starts with tpcp-docs in your organization or your developers' accounts, and for connections to scan.aquasecurtiy.org or 45.148.10.212. Neither is proof of safety if absent: the payload read the runner's memory and sent data out before the scan ran, so treat every job that ran an affected version as compromised.