10 Essential Actions to Defend Your Software Supply Chain Now

The software supply chain is under sustained attack. Not from a single threat actor or a single incident, but from an ecosystem-wide campaign that has been escalating for months and shows no signs of slowing down. Recent compromises—such as the axios library hijack, the TeamPCP worm, and the Shai-Hulud and GlassWorm campaigns—demonstrate a clear pattern: attackers steal developer credentials, use them to poison trusted packages, and those packages steal more credentials, creating a self-reinforcing cycle with ransomware monetization pipelines behind it. The common thread is implicit trust. Organizations assumed trust where they should have verified. This listicle outlines ten essential actions every engineering team should take now to move from "trust unless there's a reason not to" to "verify before you trust, and limit the blast radius when verification fails."

1. Understand the Attack Pattern

Recent supply chain attacks follow a consistent playbook: attackers gain access to a maintainer's account, inject malicious code into a popular package, and deploy versions that steal credentials from downstream users. These credentials then fuel further compromises. For example, the axios compromise planted platform-specific remote access trojans (RATs) attributed to North Korea's Lazarus Group, while the TeamPCP campaign used a worm to self-propagate into 141 npm packages. Recognizing this pattern helps teams prioritize defenses around credential protection and rapid detection of malicious updates.

2. Stop Relying on Implicit Trust

In every major incident, the failure point was the same: trust was assumed where it should have been verified. Teams trusted a container tag because it had a familiar name, or a GitHub Action because it had a version number. Attackers exploit this gap. Replace implicit trust with explicit verification at every layer. Verify base images, pin references to specific hashes instead of mutable tags, and avoid assuming that a package with many downloads is safe. This shift in default posture is the cornerstone of a resilient supply chain.

3. Adopt Verified Base Images

Don't build on artifacts you can't verify. Docker Hardened Images (DHI) are rebuilt from source by Docker with SLSA Build Level 3 attestations, signed software bills of materials (SBOMs), and Vulnerabilities Exploitability eXchange (VEX) metadata. They are free, open source under Apache 2.0, and were unaffected by the TeamPCP campaign because they are stored as artifacts with immutable digests. Using verified images ensures a known-good foundation, reducing the risk of pulling compromised builds from public registries.

4. Pin Your Dependencies

Mutable tags like :latest or version ranges such as ^1.0 can silently pull in malicious updates. Instead, pin every dependency to a specific, immutable digest or a strict version number. This applies to container images, npm packages, Python wheels, and GitHub Actions. Create a process to regularly update these pins, but only after verifying the new version's integrity through checksums or signatures. Pinning buys you time to review changes before they enter your build pipeline.

5. Use Short-Lived Credentials

Long-lived tokens and secrets are prime targets for credential theft. When an attacker compromises a developer machine or a CI/CD pipeline, they can extract tokens that remain valid for weeks or months. Implement short-lived credentials that expire within hours. Use identity-aware proxies and just-in-time access systems. For example, integrate with secret managers that issue time-bound tokens for cloud providers or package registries. This limits the window of opportunity for attackers to pivot from a compromised credential.

6. Sandbox CI/CD Environments

CI/CD runners often run with broad permissions and unrestricted network access. Attackers who poison a build step can exfiltrate data, tamper with artifacts, or deploy malware to production. Sandbox your CI/CD environments by using containers with minimal capabilities, restricting network access to only needed endpoints, and applying security policies like read-only file systems where possible. Also, separate build jobs so that a compromise in one job does not cascade to others.

7. Implement Strong Access Controls for Maintainers

Account hijacking is the entry point for most supply chain attacks. Enforce multi-factor authentication (MFA) for all maintainer accounts on package registries, version control systems, and CI/CD platforms. Use the principle of least privilege: grant only the permissions necessary for each role. Regularly audit access rights and remove inactive contributors. Consider requiring approval from a second maintainer for publishing new package versions, especially for critical libraries.

8. Monitor and Audit for Anomalies

The axios malicious versions were live for only three hours, but that was enough to cause widespread harm. Implement real-time monitoring of your supply chain: watch for unexpected changes in package versions, unusual network connections from build processes, or deviations from normal dependency update cadences. Use tools that alert on new package versions with suspicious behavior, such as obfuscated code or unexpected execution of system commands. Regular audits of dependency trees can help catch compromised packages before they propagate.

9. Harden Your Developer Accounts

Developers are the ultimate target; their credentials open the door to the entire supply chain. Enforce strong password policies, use hardware security keys for MFA, and train developers to recognize phishing attempts that aim to steal tokens. Keep personal and work accounts separate, and avoid storing credentials in code repositories, even temporarily. Use credential scanning tools to detect leaked secrets in commits. A compromised developer account can undo all other defenses if not properly hardened.

10. Plan for Incident Response

Even with the best prevention, incidents will happen. Have a playbook for supply chain attacks: who to contact, how to roll back to a known-good state, and how to communicate with internal teams and users. Practice rolling back pinned versions and rebuilding from verified base images. Maintain offline copies of critical dependencies and SBOMs. Rapid response can turn a three-hour window of exposure into minimal damage, just as organizations that had already adopted verification practices emerged with few scars from recent campaigns.

Conclusion: The software supply chain threat is accelerating, but the path to resilience is clear. By shifting from implicit trust to explicit verification—through verified base images, pinned dependencies, short-lived credentials, sandboxed environments, and strong access controls—engineering teams can significantly reduce their risk. These ten actions are not new or difficult; they require a change in default posture. Start today, and make verification the foundation of your software supply chain defense.