Software Supply Chain Security (SSCS) is the practice of protecting every link between a developer's commit and a user's installation: proprietary code, third-party components, the systems that compile and package them, the pipelines that move artifacts into production, and the identities of everyone allowed to publish a change. SSCS is not another name for scanning dependencies.
That distinction has a measurable size. In Fluid Attacks' benchmark of 36 third-party AppSec tools against a web application seeded with 1,201 vulnerabilities, 80% of the flaws sat in the application's own code and 13% in the backend, while dependencies and the frontend split the remaining 7%. An SSCS program that watches only the packages you install is watching the smallest part of its own surface.
This page covers what SSCS includes and excludes, why OWASP moved supply chain failures into its top three risks in 2025, how Fluid Attacks instruments a client's chain, how real attacks have worked, and which build and pipeline controls carry the rest.
What is Software Supply Chain Security?
SSCS is the discipline of making every link in the chain verifiable instead of assumed. The chain SSCS protects is the network of components, tools, processes and people that turn source code into a running release. Modern applications are assembled more than they are written, so most of that chain belongs to someone else.
Each third-party component carries its own dependencies, and those carry theirs, producing a dependency tree whose lower branches almost nobody has read. Knowing the component you chose without knowing the transitive dependencies it dragged in produces a false sense of security, and the deeper the tree, the more entry points an attacker inherits.
Dependencies are one link, which is why SSCS covers six surfaces rather than one:
Proprietary code: the application you wrote, which no package inventory describes.
Build systems: compilers, scripts and runners that can alter an artifact after code review.
CI/CD pipeline: workflows, runners, secrets and actions that run with publishing rights.
Identities: maintainer, committer and publisher accounts able to push a signed release.
Infrastructure: base images, registries and the configuration the pipeline deploys into.
Suppliers: the vendors and contributors whose practices you inherit with their code.
What SSCS is not is a document. An SBOM tells you what is inside the software. It says nothing about whether the build that produced it could be trusted, which is the question SSCS exists to answer.
Why SSCS moved to the top of the list
In November 2025, OWASP added Software Supply Chain Failures to its Top 10 as A03:2025, third among application security risks. It is not a renamed category: it expands 2021's Vulnerable and Outdated Components to cover compromises anywhere across dependencies, build systems and distribution infrastructure. That is the scope SSCS had been arguing for all along.
The consensus behind that scope is unusual. In OWASP's community survey, exactly 50% of respondents ranked supply chain failures as the number one risk, the strongest agreement anywhere on the list. Fluid Attacks covered the full 2025 revision when it landed.
OWASP is candid about the detection problem: only 11 CVEs map to the category's CWEs. These failures are frequent, but they rarely arrive labeled with an identifier a scanner can match. Closing that gap is the job of SSCS, and a dependency feed alone cannot do it.
Regulators got there first: Executive Order 14028 made an SBOM a condition of federal software purchases in 2021, NIST published the Secure Software Development Framework in 2022, and CISA replaced the 2021 SBOM baseline in July 2026. Such requirements travel down private supply chains fast, which put SSCS on procurement checklists years before OWASP ranked it.
Software Supply Chain Security at Fluid Attacks
SSCS at Fluid Attacks is an inventory problem and an evidence problem at once: what components are in there, and which of them an attacker can reach. What follows is what we instrument, what we can prove, and where our own numbers stop.
What we inventory, and at what granularity
The Packages section lists every third-party dependency in a group's active repositories, with vulnerabilities counted by severity. Two columns do most of the work in an SSCS review.
Transitivity marks each location as D (direct: the file imports the component), T (transitive: a direct dependency pulls it in) or U (undeterminable). Stage records whether the project depends on the component only at build time or also at run time in production, which changes the priority of the same CVE. For a transitive finding, the platform draws the dependency path from the direct dependency down to the affected package.

A dependency path in the platform: the direct dependency, the affected transitive one, and the file that connects them.
That inventory exports as an SBOM in CycloneDX or SPDX, as JSON or XML, for Git repositories or Docker images.
Declared, imported, called
A vulnerable version in a lockfile is not the same thing as exploitable code. Our static scans separate three states:
Level | What is true | What you can claim |
Latent | The vulnerable dependency is declared in the package manager, but no file imports it | It is present, and unused |
Potential | The code imports the dependency but does not call its vulnerable function | It is in play, and not demonstrably exercised |
Reachable | The code imports the dependency and calls the vulnerable function | The vulnerable path exists in your application |
Reachability also feeds the priority score of SCA findings, so an SSCS queue reflects what the application does rather than what it declares.
The limit of the numbers
Two limits are worth stating plainly, because SSCS vendors rarely state either.
First, the reachable level is only supported for CVEs that are in Fluid Attacks' own database of known vulnerable functions. Outside that list, the strongest claim we can make is potential, and we label it that way.
Second, the benchmark figure in the opening cuts against the easy pitch: dependencies were a minority of the risk in that application. SCA was never the center of gravity of the supply chain problem, and an SSCS program that stops at SCA leaves most of its surface unexamined.
The control that decides the rest
Detection without a gate changes nothing, so the last piece of SSCS is enforcement. Our CI Gate applies vulnerability acceptance policies automatically and breaks builds containing findings that are neither remediated nor accepted, under three configurable policies: a grace period for new findings, a minimum CVSS score to break the build, and the number of days after which a finding becomes technical debt.

The three policies CI Gate uses to decide whether a build passes or stops.
The difference shows up in remediation. In the State of Attacks 2026 report, covering 1,119,396 vulnerabilities reported between January 1 and December 31, 2025, clients using CI Gate remediated 72.2% of their findings, against 58% for those without it.
What SCA and an SBOM do not cover
SCA and an SBOM answer what the software contains, and say nothing about the other links. The table maps where SSCS has to pick up.
Surface | Covered by a dependency inventory | What SSCS needs on top |
Third-party components | Yes, by name and version | Evidence the vulnerable code is reachable |
Transitive dependencies | Yes, if the scanner resolves the full tree | The dependency path and the stage it runs in |
Proprietary code | No | SAST, DAST and Secure Code Review |
Secrets in the pipeline | No | Secret Scanning across code and workflows |
Build integrity | No | Reproducible builds and signed outputs |
Artifact provenance | No | Attestations tying an artifact to its build |
Publisher identities | No | MFA, scoped tokens, verified third-party components |
Base images and infrastructure | Partially, for packages inside the image | Configuration review of the deployment target |
One detail of how we count belongs in any SSCS review. Fluid Attacks reads the root lockfile and reports each CVE once per repository, whatever the number of workspaces using it. In a monorepo with a shared lockfile there is one installed copy, and one update fixes it; tools that count a finding per manifest return a bigger number for the same work. A finding count should describe the exposure, not the file layout.
This section compresses two SSCS pieces that carry a page of their own: how a component inventory gets built and assessed is covered in Software Composition Analysis, and how a vulnerable path gets confirmed is covered in reachability analysis.
How software supply chain attacks happen
A software supply chain attack compromises something upstream of you so that your own build ships it on their behalf. Six vectors account for most documented cases, and only two involve a vulnerable package, which is why SSCS cannot be delegated to a dependency scanner.
Vector | Case | What it compromised | Control that addresses it |
Signed update | SolarWinds Orion, 2020 | Malicious code inserted during the build, shipped through the official update channel | Build integrity and reproducible builds |
Build process | XZ Utils, CVE-2024-3094, 2024 | A backdoor introduced during compilation, absent from the reviewed source | Artifact provenance and attestations |
Maintainer account | npm packages, 2025 | Phishing against a maintainer produced malicious versions of 18 packages with more than 2 billion weekly downloads | MFA with hardware keys, scoped publishing tokens |
Self-propagation | Shai-Hulud, 2025 | A postinstall worm that harvested secrets and republished itself using stolen npm tokens | Install-script controls and token rotation |
CI/CD action | tj-actions/changed-files, CVE-2025-30066, 2025 | A retagged action dumped CI/CD secrets into workflow logs across more than 23,000 repositories | Actions pinned to a commit SHA |
Dependency resolution | An ambiguous dependency definition lets a public package take the place of a private one | Explicit registry and organization scoping |
Two cases deserve a correction that SSCS discussions keep blurring. Log4Shell was an inherited vulnerability, not an intrusion into Log4j's release process: a flaw in a component millions of applications had already installed. SolarWinds was the opposite. The artifact was altered during the build, so the update carried legitimate signatures through the official channel. Verification passed because the package genuinely was authentic. The malicious code was inside it, which is the failure mode SSCS exists to catch.
Securing the build and the pipeline
The CI/CD pipeline holds production credentials and gets the least testing of anything SSCS covers. NIST's SP 800-204D, published in 2024, maps supply chain assurance onto pipeline stages and supplies the vocabulary this part of SSCS needs.
Three SSCS terms get used interchangeably and should not be:
SBOM: which components the software contains.
Artifact provenance: where and how a specific artifact was built.
Attestation: signed, verifiable evidence that a stated property of that build holds.
Build integrity connects the three, and it is the piece an inventory cannot supply. An SBOM generated after a compromised build describes the compromised output faithfully.
The SSCS controls that follow are narrow and testable:
Secrets: keep credentials out of workflow logs and runner memory, which is how the tj-actions compromise did its damage.
Workflow permissions: give each job the narrowest token that lets it finish.
Third-party actions: pin them to a commit SHA rather than a tag, because tags can be moved.
Build environments: keep runners isolated and rebuilt rather than long-lived and shared.
Deployment: require that whatever reaches production passed the gate, every time.
Under DevSecOps these become pipeline conditions rather than review items, and manual penetration testing tests whether they hold against someone trying to get past them.
Conclusions
SSCS is a scope decision before it is a tooling decision. The scope OWASP ratified in 2025 covers dependencies, build systems and distribution infrastructure, and the documented attacks of the last five years hit all three. A package inventory is necessary and nowhere near sufficient: in our own benchmark, dependencies and the frontend together held 7% of the vulnerabilities found in a real application. Treat Software Supply Chain Security as the question of whether every link between a commit and an installation can be verified, then decide which links you can prove today. That inventory of evidence, not of packages, is where an SSCS program starts.
Frequently asked questions
Is Software Supply Chain Security the same as SCA?
No. SCA inventories third-party components and matches them against vulnerability data, which covers one link of an SSCS program. The rest is proprietary code, build systems, the CI/CD pipeline, publishing identities and deployment infrastructure. In Fluid Attacks' benchmark of 36 third-party AppSec tools against a 1,201-vulnerability application, 80% of the flaws were in the application's own code and 13% in the backend; dependencies and the frontend split the remaining 7%.
What does OWASP A03:2025 change for development teams?
It widens the category from vulnerable components to the whole ecosystem, build systems and distribution infrastructure included, and ranks that risk third. Exactly 50% of respondents to OWASP's community survey placed it first, the strongest consensus on the list. OWASP also notes that only 11 CVEs map to the category's CWEs, so an SSCS program cannot wait for a scanner match to announce that a supply chain failure happened.
How do you tell a vulnerable dependency from one that is actually exploitable?
By checking whether your code calls the vulnerable function, not just whether the package is installed. Fluid Attacks reports three states: latent, declared but never imported; potential, imported but the vulnerable function never called; and reachable, where the code calls that function. Reachability feeds the priority score, so an SSCS queue puts a reachable finding above a latent one with the same CVSS.
Does Fluid Attacks break the build when SSCS testing finds an issue?
Yes, when you configure it to. CI Gate breaks builds containing vulnerabilities that are neither remediated nor accepted, governed by a grace period, a minimum CVSS score and a technical-debt threshold. In the State of Attacks 2026 report, covering 1,119,396 vulnerabilities reported during 2025, clients using CI Gate remediated 72.2% of their findings, against 58% without it.
Secure the parts of your software you did not write
Our scanners and pentesters review your code, your dependencies and your pipeline from the first commit, so a compromised link is caught before it ships. Start free trial · Contact us.
Get started with Fluid Attacks' SSCS solution right now















