What is software supply chain security?
Software supply chain security practices protect all components used to build and deliver software, including source code, third-party libraries, CI/CD pipelines, and deployment infrastructure. These practices are essential to ensuring that code and systems remain secure and tamper-free before they reach production.
Prioritizing security matters because modern software relies heavily on a web of external dependencies and tools. This complexity creates more entry points for attackers. Breaches like SolarWinds and MOVEit clearly demonstrate how targeting the supply chain can lead to deep, damaging access.
Given the catastrophic potential of these attacks, regulators now demand stricter controls. In the US, for example, Executive Order 14028 and NIST’s Secure Software Development Framework (SSDF) outline requirements for federal suppliers to secure their software supply chains.
Meeting these mounting security and regulatory demands requires full visibility into your entire software supply chain—and the ability to identify and mitigate risks early. These capabilities are essential for both protection and compliance.
Software Supply Chain Security [Cheat Sheet]
Learn how to secure the software supply chain end-to-end – from managing third-party dependencies and open-source libraries to protecting build pipelines.
Components of the software supply chain that need strict security
The modern software supply chain involves many interconnected parts. Each plays a critical role in delivering secure applications, but each also introduces distinct risks.
Below are several key components teams must secure to protect their development pipeline from end to end:
Source code and version control
Source code is the foundation of any application. Developers typically manage it using version control systems such as GitHub or GitLab. If attackers exploit weaknesses—like compromised Personal Access Tokens (PATs), unprotected branches, or missing code review requirements—they can alter application logic, insert backdoors, or leak proprietary data.
To protect code integrity, teams must enforce commit signing, use branch protection rules, require reviews for merges, and tightly restrict PAT scopes and access controls.
Dependencies and third-party libraries
To accelerate development, teams often rely heavily on open-source packages and external libraries. These components deliver powerful functionality, but also carry risk—especially when attackers poison the software supply chain.
A recent example is the Shai-Hulud 2.0 campaign uncovered by Wiz Research. Attackers uploaded malicious packages to public repositories, then waited for unsuspecting developers to include them in builds. These backdoored packages could exfiltrate credentials, implant persistent access, or trigger downstream compromise—highlighting just how dangerous unverified dependencies can be.
To defend against these types of threats, your team should implement automated dependency validation, lockfile enforcement, and continuous monitoring across all package sources.
Pipelines and CI/CD tools
CI/CD pipelines power modern software delivery, automating everything from code integration to deployment. Because they sit at the center of this process, they’re a high-value target—often holding secrets, credentials, and access to production environments.
Tools like Jenkins, Travis CI, and GitHub Actions streamline builds, but they also introduce risk when misconfigured. Common vulnerabilities include unpinned actions that can be hijacked, injection of untrusted scripts, hardcoded or leaked secrets, and insecure storage of artifacts or logs. If attackers exploit these gaps, they can embed malicious code, bypass controls, or pivot into other systems.
To reduce exposure, teams must harden pipelines with least-privilege access, enforce action pinning and checksum validation, scan for exposed secrets, and isolate build environments from production.
Artifact registries and package distribution
Once built, software artifacts are stored and distributed via registries like Docker Hub, npm, or PyPI. These systems make deployment efficient but also become high-value targets. For instance, if attackers poison a package or impersonate a trusted component, compromised software can reach thousands of systems instantly. To ensure only trusted artifacts enter your environments, secure publishing practices are critical. Key controls include signing packages, enforcing access controls, maintaining provenance, scanning for malware, and validation during build and deployment.
Deployment and update mechanisms
Teams deploy modern applications using containerization and orchestration platforms like Docker and Kubernetes, which accelerate delivery and scalability. But these same mechanisms can become attack vectors if left unsecured. Every update introduces new code, and if attackers compromise an image, registry, or update process, they can inject malicious components directly into production. To block these threats, teams must verify the source of updates, enforce image signing, and scan containers for vulnerabilities and tampering before deployment.
Vendor and third-party services
Teams rely on external vendors, APIs, and cloud services to build and run applications faster. Yet, every third-party integration expands the attack surface. If a provider is breached or misconfigured, attackers can use that access to compromise your systems or data. To manage this risk, organizations must assign clear ownership, regularly assess vendors for security gaps, and enforce contractual requirements for data protection, access controls, and incident reporting.
Catch code risks before you deploy
Learn how Wiz Code scans IaC, containers, and pipelines to stop misconfigurations and vulnerabilities before they hit your cloud.
Threats and risks to the software supply chain
The software supply chain presents an attractive attack surface due to its complexity, scale, and web of interconnected components. Both external actors and internal weaknesses can introduce serious risk. Understanding these threats helps you prioritize defenses and reduce your exposure. Below are different types of threats and risks you’ll commonly encounter in a multi-cloud environment.
External threats and risks
External threats target the public-facing or third-party elements of your software development pipeline. These threats include poisoned updates, malicious dependencies, and man-in-the-middle attacks, which exploit gaps in validation or transport security.
| External threats and risks | Description | Real-world examples |
|---|---|---|
| Malicious code injections and compromised dependencies | Attackers inject malicious code into third-party libraries or tamper with trusted, reused dependencies. These attacks can include supply chain compromises at the source. | During the SolarWinds attack, attackers inserted malware into a routine software update, triggering global breaches of government and enterprise systems. |
| Man-in-the-middle attacks | These attacks intercept software during distribution and alter it before it reaches users. Risk increases with weak validation or unsigned updates. | Operation ShadowHammer attackers compromised ASUS’s Live Update utility to push malicious updates to users via ASUS’s own infrastructure. |
| Lack of encryption in data transmission | Unencrypted updates allow attackers to intercept and manipulate files in transit. This enables tampering and malware injection. | In the Ivanti Connect Secure VPN attacks, attackers exploited known vulnerabilities and unencrypted data transfers to execute remote code without authentication. |
Internal threats and risks
Internal threats arise from within the organization or through trusted systems. These threats include insider risks, misconfigurations, and credential misuse. Even one compromised developer account can undermine the entire pipeline.
| Internal threats and risks | Description | Real-world examples |
|---|---|---|
| Insider threats or compromised developer accounts | Stolen credentials or malicious insiders grant attackers access to sensitive systems, enabling them to tamper directly with the build process. | In the Codecov breach, attackers exploited a minor modification to a CI script to exfiltrate secrets from compromised builds, gaining access via a compromised Docker image. |
| Outdated components and flawed software with known vulnerabilities | Using outdated or unpatched software exposes your environment to known exploits. These vulnerabilities are often publicly documented and accessible. | The Equifax breach, traced to an unpatched Apache Struts vulnerability, resulted in the loss of over 140 million consumer records. |
| Insecure APIs | Poorly secured APIs expose applications to unauthorized access, data leakage, and privilege escalation. | WhatsApp’s 2024 “View Once” flaw exposed an API vulnerability that allowed attackers unauthorized access to its disappearing media feature, undermining user privacy controls and highlighting the risk of unsecured endpoints. |
Real-life examples of software supply chain attacks
Each of the following cases reveals how gaps in isolation, validation, or configuration can open the door to wide-reaching exploitation.
Hugging Face and researchers find a malicious AI model
In 2024, Wiz Research collaborated with Hugging Face to uncover a critical security risk in its Inference API. Attackers could exploit this flaw to upload a malicious AI model capable of remote code execution (RCE) and cross-tenant access. Because the AI model wasn’t running in an isolated environment, an attacker could access private customer data and sensitive models from other tenants.
Wiz researchers also identified weak tenant isolation in the underlying Kubernetes infrastructure. This flaw enabled privilege escalation and lateral movement across the environment. Additionally, the Spaces service had gaps in its container registry security, which could have enabled attackers to manipulate containers and infrastructure at scale.
What failed: Inadequate isolation between tenants and a lack of container validation
How it was exploited: Malicious model uploads triggered remote code execution and cross-tenant access
What would have helped: Strict tenant boundaries, more robust container scanning, and model validation controls before execution
Following these findings, Hugging Face acted quickly to strengthen tenant isolation, expand its vulnerability scanning, and harden its container environments.
Wiz uncovers #IngressNightmare
Wiz Research uncovered a severe unauthenticated remote code execution vulnerability in the Ingress NGINX Controller for Kubernetes, now known as #IngressNightmare. The issue stemmed from insecure logic in the admission controller webhook, which allowed attackers to bypass authentication and gain access to Kubernetes clusters.
The vulnerability affected approximately 43% of cloud environments and over 6,500 internet-exposed clusters. Attackers could exploit this path to escalate privileges and access secrets across multiple namespaces, which threatened core infrastructure and application layers.
What failed: Insecure input validation in the admission controller and unrestricted access to webhook endpoints
How it was exploited: Attackers sent crafted requests to trigger RCE without authentication
What would have helped: Securing the webhook with network policies, restricting its exposure, and applying strict admission controls
Wiz quickly provided detection capabilities to identify exposed clusters and issue real-time alerts. Affected organizations mitigated the issue by updating NGINX, restricting webhook access, and applying tighter Kubernetes network policies.
The State of Code Security [2025]
Supply chain attacks are on the rise, with attackers targeting repositories, dependencies, and CI/CD workflows. The State of Code Security Report 2025 found that malicious NPM and PyPI packages remain a major concern, reinforcing the need for stronger security controls.
Download report
The Shai-Hulud 2.0 supply chain attack (in-depth)
The Shai-Hulud 2.0 supply chain attack, uncovered by Wiz Research, is among the most expansive npm-based compromises to date. Threat actors trojanized nearly 700 npm packages, affecting over 25,000 GitHub repositories across hundreds of users.
These packages exfiltrated secrets from CI/CD pipelines and developer machines during the preinstall phase, enabling wide-scale credential theft and backdoor persistence. The malware leveraged GitHub workflows to remain undetected and facilitate cross-victim data exposure, targeting secrets from AWS, Azure, and GCP environments.
What failed: Compromised maintainer credentials allowed attackers to publish trojanized npm packages with malicious preinstall scripts.
How it was exploited: Installing these packages triggered credential theft, secret exfiltration, and GitHub Actions–based persistence.
What would have helped: Blocking lifecycle scripts by default, enforcing scoped tokens, and strictly validating packages before installation.
This campaign underscores the growing need for automated dependency validation, hardened build systems, and real-time monitoring to protect software pipelines.
Best practices for mitigating supply chain risks
Protecting your software supply chain requires a layered approach. From code development to deployment, every stage demands controls that reduce exposure and enable fast response.
Below are 12 essential best practices to proactively strengthen your defenses and build long-term resilience:
1. Create a software bill of materials with security considerations
Visibility is the foundation of software supply chain security. A complete, up-to-date Software Bill of Materials (SBOM) gives you detailed insight into all components in your codebase—including direct and transitive dependencies, open-source packages, and proprietary modules.
To ensure interoperability and compliance, generate your SBOM using standardized formats like SPDX or CycloneDX. These formats are widely supported and enable integration with auditing tools, compliance platforms, and third-party assessments. The SBOM should include metadata for each component, such as version, origin, and license, and must be updated continuously as your code changes.
Platforms like Wiz automate SBOM generation across cloud-native environments using agentless scanning, which reduces manual overhead while maintaining inventory accuracy.
Why it matters: This ensures your security team stays aligned with evolving standards such as Executive Order 14028 and NIST’s SSDF, while developers stay focused on delivery.
2. Leverage DevOps and DevSecOps
Shift security left by embedding it directly into your development pipeline. This means scanning both your proprietary code and your third-party dependencies—each requires different approaches.
To analyze your code for logic flaws, insecure coding patterns, and misconfigurations, use SAST tools like SonarQube or Checkmarx. For dependencies, use SCA tools to inspect third-party packages and libraries for known vulnerabilities, outdated versions, and licensing risks.
A DevSecOps model integrates both approaches into CI/CD workflows, bringing together security, development, and operations teams. This shared-responsibility mindset fosters earlier issue detection and faster remediation—without slowing down delivery velocity.
Why it matters: Catching issues early limits risk exposure, reduces rework, and prevents vulnerabilities from reaching production, ultimately saving time, reducing costs, and protecting reputation.
CI/CD Supply Chain Attack
Hosted by experts Eden Naftali and Amitai Cohen, the Crying Out Cloud podcast provides in-depth coverage of the most important vulnerabilities and incidents from the previous month. Tune in for insightful analysis and expert recommendations to help you safeguard your cloud infrastructure.
Listen now
3. Complete regular audits
Audits help you catch what automation might miss. Schedule routine assessments of code dependencies, cloud configurations, and infrastructure. Tools like OWASP Dependency-Check and AWS Config help you identify misconfigurations and outdated libraries. Here’s how:
| Audit focus | Tools | Key benefit |
|---|---|---|
| Dependencies | OWASP Dependency-Check and Snyk | Detect and prioritize known vulnerabilities. |
| Cloud configs | Wiz, AWS Config, and Azure Security Center | Spot risky misconfigurations across your environment. |
| Network behavior | Wiz and ELK Stack | Identify anomalies in traffic patterns. |
Why it matters: Regular audits expose the blind spots automated tools can overlook and ensure your security posture keeps pace with evolving threats, infrastructure changes, and new compliance mandates.
4. Implement multi-factor authentication and enforce least-privilege access
Access controls matter at every layer. To protect access, enable MFA on all developer tools and cloud services. Also, enforce least-privilege permissions across repositories and CI/CD systems so users have only the exact permissions they need for their roles.
Why it matters: MFA and least-privilege access prevent attackers from using compromised accounts to escalate access.
5. Perform software composition analysis
Software composition analysis (SCA) tools scan third-party libraries for known issues. Integrate them into your pipeline to automatically detect outdated or vulnerable packages. This practice is critical in cloud-native environments, where codebases often rely heavily on open-source components.
Why it matters: SCA proactively protects you from external risks introduced by dependencies.
6. Choose a continuous monitoring solution
Security doesn’t end at deployment. You need continuous monitoring to detect active threats. Use tools like AWS CloudWatch, Azure Sentinel, or Wiz to track workloads, configurations, and activity across your cloud environments in real time. These solutions provide visibility into issues, enabling quick detection and response before they escalate.
Why it matters: You can’t fix what you can’t see. Continuous monitoring ensures you don’t miss a threat.
7. Enforce code signing and tamper detection
Secure your software supply chain by signing every build and artifact with cryptographic keys. Additionally, validate those signatures during deployment and use checksums to detect any unexpected modifications. These safeguards ensure that only trusted, verified code reaches production.
Why it matters: These enforcements prevent unauthorized changes before software deployment, which protects your environment from tampered or malicious code.
8. Secure build infrastructure and CI/CD systems
Your pipeline is a high-value target. Harden build environments with strict access policies, secret management, and network segmentation. Monitor these systems for anomalies that could indicate compromise.
Why it matters: A compromised CI/CD system gives attackers a direct path to production.
9. Manage vendor risk
Third-party services introduce risks you don’t directly control. Evaluate every vendor’s security posture, incident response readiness, and historical track record. Additionally, regularly review and renew these assessments to maintain compliance and trust.
Why it matters: Your security is only as strong as the weakest link in your supply chain.
10. Create an incident response plan
Supply chain compromises often involve trusted components—making them harder to detect and slower to contain. For this reason, ensure your incident response plan includes specific playbooks for software supply chain threats.
Define procedures for detecting tampered artifacts, compromised registries, malicious dependencies, or build system intrusions. Your plan should outline how to revoke compromised packages, coordinate vendor notifications, update SBOMs, and validate build integrity across environments. Just as important: run simulated supply chain breach scenarios to test your team’s coordination across security, engineering, and third-party contacts.
Why it matters: Unlike traditional incidents, supply chain attacks often propagate silently into downstream systems. A tailored IR plan ensures you act fast to contain the impact and restore trust.
11. Use network segmentation
Isolate environments like development, staging, and production to reduce risk and limit the lateral spread of threats across your network. Implement micro-segmentation and zero trust principles to control access at a granular level.
Why it matters: Containment reduces the blast radius if an attacker or misconfiguration compromises part of your system.
12. Schedule regular backups
Don’t just back up data—back up your software artifacts, configurations, and metadata, too. Use cloud-native solutions, like AWS Backup or Azure Backup, and regularly test recovery procedures to ensure business continuity.
Why it matters: Rapid recovery minimizes downtime and keeps you operational when incidents occur.
How to keep your software supply chain protected
Protecting your software supply chain is no longer optional. Since modern applications rely heavily on open-source components, third-party services, and distributed infrastructure, organizations face compounding risks from both external attackers and internal weaknesses. As a result, forward-thinking teams are prioritizing not just detection and response, but also prevention, governance, and assurance.
Here are some strategies to build a resilient defense:
Leverage established frameworks
Adopting well-defined industry frameworks is the foundation of a strong supply chain security strategy. The following standards help to structure your approach to risk identification, mitigation, and governance:
| Framework | Purpose |
|---|---|
| ISO/IEC 27001 | Defines requirements for information security management systems and risk controls. |
| NIST Cybersecurity Framework | Offers a flexible, risk-based approach to securing infrastructure and supply chains. |
| NIST’s SSDF | Guides secure coding and lifecycle practices to reduce exploitable software flaws. |
| Supply-chain Levels for Software Artifacts (SLSA) | Introduces graduated levels of software integrity and provenance controls. |
| Cloud Security Alliance Cloud Controls Matrix | Maps security controls to cloud-specific risks, including those that affect supply chains. |
Implementing these frameworks improves your risk posture, simplifies compliance, and reinforces trust across customers and stakeholders. Crucially, they pave the way for automated enforcement when paired with tools like Wiz, which helps teams implement policy-driven controls, validate supply chain integrity, and monitor for emerging threats.
Align with rising governance and assurance expectations
Governments and industries are tightening supply chain oversight with new mandates, laws, and executive orders. These mounting expectations from regulators and customers are making software attestation, third-party assurance, and documented SBOMs table stakes, especially for companies operating in regulated or public-sector environments.
Emerging standards, such as the minimum elements for an SBOM (per NTIA and Executive Order 14028), are evolving. This regulatory pressure increasingly motivates insurers and regulators to request documented proof of the following details:
Comprehensive SBOM coverage
Secure build pipelines and tamper-proof releases
Rigorous third-party vendor assessments
Hardware origin tracking
Wiz helps teams automatically generate SBOMs, detect gaps, and enforce compliance with standards such as NIST’s SSDF and SLSA without requiring agents or slowing the pipeline.
Prepare for emerging threats
As organizations race to adopt generative AI, attackers are adapting just as fast. Threat actors are already using AI to accelerate supply chain attacks, like scanning public registries for exposed secrets and crafting highly convincing malicious packages. Meanwhile, forward-thinking security programs are taking these steps to stay ahead:
Enforcing zero trust for build systems: Verifying every step of the build process—including who triggered it, what code changed, and where artifacts are stored—to provide stronger security.
Exploring supply chain insurance: Evaluating coverage options that hinge on evidence of strong security hygiene, such as up-to-date SBOM practices, rigorous vendor assessments, and secure CI/CD processes.
Demanding third-party attestation: Requesting documented proof from vendors that they follow secure development practices and can respond quickly to supply chain threats.
Ask suppliers questions based on NIST guidance
When assessing third-party software, ask these questions derived from NIST’s SSDF and software sourcing guidance to ensure vendors meet your security standards:
Does the supplier have foreign government affiliations?
Can they provide a complete sourcing list for hardware and software components?
Do they safeguard sensitive data from unauthorized access or transfer?
Is there a clear process for secure maintenance and updates?
Can they demonstrate risk mitigation across the product lifecycle?
Do they follow recognized, secure development frameworks?
By combining strong frameworks, proactive security controls, and vendor accountability, you can transform your software supply chain into a strategic advantage—not a lurking liability. Wiz accelerates this journey by providing the visibility, automation, and context you need to secure every layer of your software development pipeline.
Secure all components of your software supply chain with Wiz
Wiz’s CNAPP secures your software supply chain from code to cloud by integrating seamlessly into your CI/CD, DevSecOps, and cloud environments. With agentless deployment and deep visibility, our solution helps you reduce risk without slowing development. Here’s how:
| Risk area | Wiz capability |
|---|---|
| SBOM integrity | Auto-generates and signs SBOMs, detecting changes and drift. |
| Artifact trust | Tracks origin and validates build artifacts across the pipeline. |
| CI/CD visibility | Monitors pipelines for exposed secrets and unauthorized changes. |
| Dependency risk | Scores third-party components based on actual exposure, not CVSS. |
| Runtime linkage | Connects vulnerabilities to active workloads for faster triage. |
| Vendor and service risk | Surfaces third-party connections and tracks their security posture. |
| Real-time alerting | Sends context-rich alerts and integrates with remediation workflows. |
Wiz seamlessly integrates into existing tools and workflows across AWS, Azure, GCP, GitHub, GitLab, Jenkins, and more. We unify teams around a shared, risk-driven view of your cloud and software supply chain and help you stop threats before they reach production.
Ready to learn how Wiz can help you secure every step of your software supply chain? Book a demo today to uncover risks and strengthen your defenses across your multi-cloud environment.
Secure Every Stage of the SDLC
Learn how Wiz is solving security challenges of Developer and DevSecOps team.
FAQ
Here are some common questions people ask about software supply chain security: