Software composition analysis

Also known as: dependency scanning

On this page 7

Software composition analysis (SCA) is the practice of automatically identifying every open-source and third-party component inside an application and checking each one against databases of known vulnerabilities, license terms and maintenance status. In application security, SCA addresses a risk that code review of first-party source cannot reach: modern applications often consist of 70 to 90 percent borrowed code, pulled in through package managers, container images and copied libraries.

The practice is also widely called dependency scanning, although mature SCA covers more than the dependency manifest. It feeds remediation workflows, release gates and the software bill of materials (SBOM) that customers and regulators increasingly request.

How software composition analysis builds an inventory

SCA works by first producing a complete component inventory and then matching that inventory against vulnerability and license intelligence. The inventory step determines the quality of everything that follows, because a component that is never detected can never be flagged.

Tools combine several detection techniques. Manifest parsing reads files such as package.json, pom.xml or requirements.txt; lockfile analysis resolves the exact versions installed, including transitive dependencies that the developer never chose directly. Binary and container analysis inspects compiled artifacts and image layers, while file fingerprinting uses hashes or code snippets to recognize libraries that were vendored or copied without a manifest.

The following table compares the main detection techniques and what each one tends to miss.

TechniqueWhat it inspectsTypical blind spot
Manifest parsingDeclared dependencies and version rangesExact resolved versions, copied code
Lockfile resolutionPinned direct and transitive versionsComponents installed outside the package manager
Binary analysisCompiled JARs, DLLs, shared objectsHeavily modified or obfuscated code
Container image scanningOperating system packages and layersApplication libraries without metadata
Snippet fingerprintingHashes of files or code fragmentsSmall or rewritten snippets; higher cost
Detection techniques used in software composition analysis

After identification, each component is normalized to a standard identifier, commonly a Package URL (purl) or a CPE name, and matched against sources such as the National Vulnerability Database, the GitHub Advisory Database and OSV. Identifier mismatches between ecosystems remain a leading cause of both false positives and missed findings.

What SCA findings report

An SCA finding links a specific component version to a specific risk category, most often a CVE, a license obligation or an operational concern. Good tools report all three, because a vulnerability-free component can still create legal or maintenance exposure.

The categories below summarize the typical outputs and the decisions they drive.

Finding typeExample signalUsual response
Known vulnerabilityCVE with CVSS score and fixed versionUpgrade, patch or mitigate
License riskStrong copyleft such as GPL or AGPLLegal review, replacement or compliance steps
Unmaintained componentNo release for several yearsPlan migration to an active alternative
Malicious packageTyposquatted or hijacked package nameRemove immediately and investigate exposure
Outdated versionSeveral major versions behindSchedule upgrade to reduce future debt
Risk categories in SCA results

Severity alone is a poor guide to priority. Mature programs add exploitability context: the EPSS probability score, inclusion in the CISA Known Exploited Vulnerabilities catalog and, above all, reachability analysis, which checks whether the application actually calls the vulnerable function. Reachability can cut the actionable backlog substantially, although results depend on language support and the accuracy of call-graph construction.

SCA compared with SAST, DAST and SBOM

SCA differs from other testing methods because it examines code the team did not write. Static application security testing (SAST) analyzes first-party source for flaws such as SQL injection or XSS, while dynamic testing (DAST) probes the running application from outside.

The comparison below clarifies where each practice fits.

PracticePrimary targetTypical output
SCAThird-party and open-source componentsVulnerable or risky dependencies
SASTFirst-party source codeCoding flaws with file and line
DASTRunning applicationExploitable behavior at runtime
SBOMComponent inventory as a documentCycloneDX or SPDX file
Secrets scanningRepositories and build artifactsExposed keys and credentials
SCA and related application security practices

An SBOM is best understood as a standardized output of the inventory step rather than a competing tool. SCA produces and consumes SBOMs in CycloneDX or SPDX format, and continuous SCA keeps the SBOM meaningful by re-evaluating it as new advisories appear.

Integrating SCA into the development lifecycle

SCA delivers the most value when it runs at several points in the lifecycle, not as a single pre-release audit. Each placement catches a different class of problem at a different cost.

  • In the IDE and pull request, so developers see a risky dependency before it is merged.
  • In the CI pipeline, with a policy gate that blocks builds containing critical, reachable vulnerabilities or forbidden licenses.
  • In artifact registries and container registries, to stop unapproved packages from entering the organization.
  • In production monitoring, because a component that was clean at release can receive a new CVE months later.

Policy design matters more than tool choice. A gate that fails every build on any medium finding quickly produces alert fatigue and bypassed controls. Effective policies combine severity, reachability, fix availability and exposure of the affected service, and they allow documented, time-limited exceptions when no fix exists.

Automated pull requests that propose version upgrades reduce remediation effort, but they still require regression testing, because a minor version bump can introduce breaking behavior.

Limitations and common mistakes

SCA is only as reliable as its inventory and its vulnerability data, and both have systematic gaps. Teams that treat a clean report as proof of safety misread what the tool measures.

The table lists frequent problems, their causes and practical fixes.

SymptomLikely causeRemedy
Thousands of open findingsNo prioritization by reachability or exposureAdd reachability and EPSS-based triage
Vulnerable library not reportedVendored or copied code without manifestEnable fingerprinting or binary scanning
Different results between toolsDivergent advisory sources and identifiersStandardize on purl and compare sources
Findings reappear after fixesTransitive dependency pulls old versionUse overrides or resolutions in the lockfile
Zero-day not detectedAdvisory not yet publishedCombine SCA with runtime monitoring
Common SCA problems and remedies

SCA also cannot judge intent or behavior: a newly published malicious package without an advisory may pass unnoticed. Supply-chain defenses such as package provenance verification, signed artifacts and curated internal mirrors complement SCA rather than replace it.

Explained without jargon

Most software is assembled from ready-made parts written by other people. A house is built the same way, from bricks, pipes and wiring bought from suppliers. Software composition analysis lists every one of those parts. It then checks whether any part has been recalled for a safety defect. It also checks whether a part comes with rules on how it may be used.

Without this check, a team may not know which parts its product contains. With it, the team gets a clear list. It learns which parts are dangerous and which ones to replace first.

A typical use case

A mid-sized online retailer runs a Java checkout service with 40 direct dependencies that resolve to roughly 310 components in total. When a critical remote code execution flaw is announced in a widely used logging library, the security team queries its SCA platform and finds the vulnerable version in seven services, five of them through transitive dependencies that no developer had chosen consciously.

Reachability analysis shows that only three services actually invoke the vulnerable code path, so those are patched within 24 hours while the remaining four are upgraded in the next scheduled release. The CI policy is then updated to block any build containing the affected versions, and the refreshed SBOM is shared with two enterprise customers who had requested evidence of remediation.