Table of contents
Title
Table of content
Table of contents
Title

Software Supply Chain Security (SSCS)

Updated

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.

Dependency path from a direct dependency to an affected transitive one

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.

CI Gate policies that decide when a build is broken

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

Dependency confusion

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

Reduce risk without slowing delivery

Fast and accurate results from one continuous security program powered by AI, scanners, and pentesters.

Reduce risk without slowing delivery

Fast and accurate results from one continuous security program powered by AI, scanners, and pentesters.

Reduce risk without slowing delivery

Fast and accurate results from one continuous security program powered by AI, scanners, and pentesters.