Software supply chain failures: the category that starts before the request
Software supply chain failures are what OWASP calls breakdowns or other compromises in the process of building, distributing or updating software. It is A03 in the OWASP Top 10:2025. Most of it happens in places a visitor never touches, so a request filter reaches only a thin slice: a known flaw in a component can be matched for a while, and a poisoned build cannot.
Quick facts
- Category
- A03:2025 Software Supply Chain Failures; in 2021 the nearest category was A06 Vulnerable and Outdated Components
- Mapped weaknesses
- Six CWEs, among them CWE-1104 Use of Unmaintained Third Party Components and CWE-1395 Dependency on Vulnerable Third-Party Component
- Occurrences in OWASP's data
- 215,248
- Community survey
- Ranked first by exactly 50% of respondents to the Top 10 survey
- Does a WAF stop it?
- Only a narrow part. A request that exploits a known component flaw can be matched while the component is replaced; a compromised build or package never arrives as a request
Figures are from the A03:2025 page of the OWASP Top 10 and from its 2025 index.
What the category covers
The category is about the path code takes before it runs for your users: written by someone else, built somewhere, stored in a registry, fetched, installed and updated. A weakness anywhere on that path counts, whether it is an old flaw in a library or a deliberate change slipped into one. Known flaws in dependencies are tracked as CVE entries.
OWASP lists the signs that an application is probably exposed.
- Versions are not tracked. That includes client-side and server-side components and their transitive dependencies, the ones your dependencies pull in.
- Software is unsupported or outdated. The list names the operating system, servers, databases and libraries.
- Nobody scans or reads bulletins. Flaws in components are published; the exposure is not hearing about them.
- Changes in the pipeline are not controlled. OWASP points to IDEs, repositories and artifact stores, and to missing least privilege and separation of duties.
- Components come from untrusted sources. Or fixes wait for a monthly or quarterly patch cycle, or updated libraries are never tested for compatibility.
- The CI/CD pipeline is weaker than what it deploys. Whoever controls the build controls what ships.
Three stages recur in that list: dependencies (what you pull in), the build (how it becomes an artifact), and distribution (how it reaches users and servers). The rest of this page uses those three. A dependency flaw that reached many applications is described in Log4Shell. A third-party script on a payment page is one case: formjacking.
How it differs from the 2021 category
The 2021 edition had A06 Vulnerable and Outdated Components. Its subject was narrower: an application is exposed when it relies on libraries, frameworks or servers that have known flaws, are no longer supported or are not kept up to date.
The 2025 edition keeps all of that and adds the process around it. OWASP says the category first appeared in the 2013 list as "A9 – Using Components with Known Vulnerabilities" and has since expanded to cover all supply chain failures, not only known vulnerabilities. The practical change is the question you ask. Under the old name it was "is this component patched?" Under the new one it is also "is this component what it claims to be, and was it built by the pipeline I think built it?"
A sibling category sits close by. Software or data integrity failures covers code, updates or data that are trusted without verifying where they came from. The two overlap at the update channel, and A03 is the broader one about how software is made and shipped.
Cases OWASP cites
OWASP's attack scenarios on the A03 page are worth reading in full. Briefly:
- SolarWinds. OWASP describes a compromised trusted vendor, with about 18,000 organisations affected through its upgrades.
- Shai-Hulud. A self-propagating npm worm that infected developer machines, exfiltrated data and reused npm tokens to publish malicious package versions. OWASP puts it at more than 500 package versions before npm disrupted it.
- Component flaws. Components run with the privileges of the application, so a flaw in one can be as serious as a flaw in your own code. OWASP names CVE-2017-5638 in Struts 2 and CVE-2021-44228, known as Log4Shell, both leading to remote code execution.
The first two are cases where the code that arrived was already hostile. The third is a case where the code was ordinary and carried a defect. They need different answers, and the next two sections separate them.
What reduces the risk
The OWASP prevention list reads as a set of habits. Four of them do most of the work.
Know what you run
OWASP recommends centrally generating and managing a software bill of materials, including transitive dependencies, and inventorying component versions continuously; it names OWASP Dependency-Track and Dependency-Check as tools. CISA describes an SBOM as "a nested inventory, a list of ingredients that make up software components". An inventory is the precondition for everything else: you cannot patch what you did not know you had.
Choose versions on purpose
The same list says to pick dependency versions deliberately and upgrade only when needed, to remove unused dependencies and features, and to watch CVE, NVD and OSV feeds, with software composition analysis to automate it. Pinning a version makes a change visible; it also means a fix does not arrive on its own, so the feeds matter.
Check where components come from
OWASP says to obtain components only from trusted sources over secure links and to prefer signed packages. For the build, it names MFA, signed builds and artifact provenance. SLSA is the framework that organises this: its v1.0 has a single Build track, and the track "protects against tampering during or after the build". NIST SP 800-218, the Secure Software Development Framework, is the broader reference for secure development practices.
Make the pipeline harder than the product
Track changes to CI/CD settings, repositories, IDEs, SBOM tooling, logs, third-party integrations and registries. Update the tooling itself. Roll updates out in stages or as canaries rather than to every system at once, so that one bad release reaches a few machines first.
Where a WAF helps and where it does not
A request filter sees requests. That settles most of this section.
Where it helps
The A03 page itself says that for unmaintained components, teams should use migration or virtual patching when a fix is not available. This is the one place the category and a WAF meet. When a component in your stack has a published flaw that is reached through a request, such as the Struts and Log4Shell cases above, a rule describing that way in can refuse the request while the update is tested. That is virtual patching: a narrow, temporary rule, not a fix. A rule for one known route into a flaw does not describe other routes into it, which is why the shared rule sets and your own rules need updating as the flaw becomes better understood.
Where it does not
- A compromised build or package. The hostile code arrives through your pipeline and runs inside your application. No visitor's request carries it, so there is nothing to match.
- A flaw with no request shape. If the defect is reached by a request that looks like any legitimate one, a rule cannot tell them apart.
- Not knowing what is installed. A request filter holds no inventory of your dependencies. It cannot tell you which component is outdated.
- The rest of the pipeline. Repositories, developer machines and registries are not behind your site's front door.
Starting a virtual patch
Begin in monitor mode. The activity log shows what the rule would have matched, and the false positives that surface are cheaper to find there than in blocked customer requests. Move to block when the matches are only the traffic you meant to refuse, and remove the rule once the component is updated, or it becomes an unexplained rule nobody dares to delete.
The injection and integrity categories show the other ends of the range: injection is where a filter reaches most, and integrity failures is where it reaches little.
Questions
What are software supply chain failures?
In the OWASP Top 10:2025, software supply chain failures are breakdowns or other compromises in the process of building, distributing, or updating software. They often come from vulnerabilities or malicious changes in third-party code, tools or dependencies.
How is A03:2025 different from Vulnerable and Outdated Components?
The 2021 category, A06 Vulnerable and Outdated Components, was about components with known flaws or no support. A03:2025 keeps that and widens it to the whole path of building, distributing and updating software, including malicious changes and the build pipeline itself.
Can a WAF fix a vulnerable dependency?
No. A WAF can refuse requests that match a known way of reaching a flaw in a component, which buys time as a virtual patch. The component still contains the flaw until it is updated or replaced.
Can a WAF detect a compromised build or package?
No. A tampered build arrives through your own pipeline, not through a visitor's request, so there is nothing for a request filter to match. Provenance checks, signed artifacts and pipeline hardening are the controls for that.
Where should a virtual patch start?
In monitor mode. Record what the rule would have matched, check that your own traffic does not trip it, and move to block once the matches look right.