An SBOM lists all components accurately. However, if the build system itself was compromised (like in SolarWinds), or if a legitimate maintainer account was compromised to inject backdoor code, the SBOM still looks 100% valid.
Software supply chain attacks have become the dominant intrusion pattern of the current threat landscape, and the numbers back up why it deserves board-level attention rather than a line item in a broader security budget. Sonatype identified over 454,600 new malicious open source packages in a single recent year, a 75 percent year-over-year increase, bringing the cumulative total of known malicious packages past 1.2 million — with more than 99 percent of that volume concentrated on npm alone. Third-party involvement in breaches has doubled year over year according to industry breach reporting, the largest single-year shift ever recorded in that data, and a supply chain compromise now takes an average of well over 250 days to identify and contain, the longest lifecycle of any breach vector tracked.
The second problem is that attackers aren't relying on sophisticated zero-days to pull this off. The consistent pattern across recent major incidents is maintainer account takeover through credential stuffing, phishing, and SIM swapping, followed by publishing a malicious package version through an entirely legitimate, properly signed, authenticated channel. Traditional signature verification alone is structurally insufficient against this pattern, because the malicious code arrives with a completely valid signature from a genuinely compromised, previously trustworthy account — and dependency confusion attacks have grown more targeted, with attackers actively researching internal package naming conventions from job postings and public repositories before registering the matching malicious public package.
The third problem, increasingly relevant, is AI coding assistants introducing an entirely new failure mode: hallucinated dependencies. AI tools frequently suggest package names that don't actually exist, or that exist but are outdated or already known to be vulnerable, and a substantial share of AI-suggested dependency versions carry real risk from hallucination or known vulnerabilities. Attackers have begun registering the specific non-existent package names AI assistants reliably hallucinate, waiting for a developer to accept the suggestion on a tab-complete — a technique with real room to scale as AI-assisted development adoption continues to grow.
We build supply chain security around verifiable provenance rather than implicit trust — Software Bills of Materials that are living and continuously enriched rather than static exports, combined with SLSA-aligned build provenance that cryptographically documents how every artifact was actually built, not just what components it claims to contain. This matters specifically because an SBOM alone would not have caught incidents like SolarWinds, where every listed component was technically legitimate and the compromise happened inside the build process itself — provenance verification is what catches that category of attack, and it's the layer most supply chain security programs are still missing.
For the credential-based attack pattern now dominant in the field, we implement short-lived, OIDC-based credentials for CI/CD systems in place of long-lived static keys, scope build permissions to the minimum required for each specific job, and isolate build environments so no single compromised system controls both source and build execution. For AI-assisted development specifically, we establish dependency curation policies that block packages that are too new, unmaintained, or otherwise suspicious before they ever reach a developer's environment, and build validation specifically for AI-suggested dependencies, given how frequently those suggestions carry real, documented risk.
System Features
01.Living, Enriched SBOM Generation
Continuously updated software bills of materials enriched with Vulnerability Exploitability eXchange data, replacing static, point-in-time exports.
02.SLSA-Aligned Build Provenance
Cryptographic provenance attestation for every build, documenting how an artifact was actually produced, not just what it claims to contain.
03.Short-Lived Credential Architecture
Long-lived static CI/CD credentials replaced with short-lived, OIDC-based tokens scoped to minimum required permissions.
04.AI Dependency Validation
Specific validation for AI-suggested dependencies, given the documented frequency of hallucinated, outdated, or vulnerable package suggestions from AI coding assistants.
05.Perimeter Package Curation
Automated policies blocking packages that are too new, unmaintained, or otherwise high-risk before they reach a developer's environment.
SBOM and SLSA as Complementary, Not Redundant, Layers
An SBOM answers one specific question: what components does this software contain. SLSA answers a different, equally necessary question: how was this software actually built, and can that build process be independently verified. The distinction matters enormously in practice — the SolarWinds compromise would have produced a perfectly accurate SBOM listing every legitimate component, because the attackers didn't add a new malicious dependency, they compromised the build system itself and injected malicious code during compilation. No SBOM, however complete, would have flagged that, because every listed component genuinely was what it claimed to be. Build provenance is the layer that would have caught it, by cryptographically verifying that the artifact produced actually matches what the documented source and build configuration should have generated.
Our supply chain architecture treats these as genuinely complementary controls operating at different layers. SBOM generation, continuously enriched with exploitability context rather than exported once and left stale, gives you accurate visibility into your dependency tree and lets you respond quickly when a new CVE affects a component you actually use. SLSA-aligned provenance, implemented through tools like Sigstore's keyless signing — where developers authenticate through existing identity providers rather than managing long-lived signing keys, and every signing event is recorded in an immutable, publicly verifiable log — gives you the build-integrity layer that catches compromise at the point of construction rather than only at the point of known-vulnerability disclosure. Progressing to full SLSA Level 3, with builds running in isolated, ephemeral environments and signing secrets kept separate even from the build configuration itself, closes the gap where even a malicious insider with access to build configuration cannot forge a valid provenance attestation.
// Real-World Use Cases
- >Organization needing to move from static, point-in-time SBOM exports to a continuously enriched, living inventory
- >Company needing SLSA-aligned build provenance to satisfy enterprise procurement or regulatory requirements
- >Engineering team with heavy AI coding assistant adoption needing specific protection against hallucinated dependency risk
- >Business still relying on long-lived static CI/CD credentials needing migration to short-lived, scoped access
- >Organization needing a comprehensive supply chain security assessment following a third-party or open-source-linked incident
// Measurable Business Impact
- ✔Provides genuine detection capability for build-process compromises that SBOM visibility alone cannot catch
- ✔Directly addresses the maintainer-account-takeover pattern behind the majority of recent major supply chain incidents
- ✔Closes the emerging AI-dependency risk gap specific to hallucinated and slopsquatted package names
- ✔Reduces the average detection and containment time associated with supply chain compromises, currently the longest of any breach vector tracked
- ✔Supports SBOM and provenance requirements increasingly expected in procurement, regulatory, and enterprise security review contexts
Frequently Asked Questions
Verify what you didn't write yourself
Living SBOMs, cryptographic build provenance, and credentials that expire before they can be exploited.
Scope your supply chain security program