Beyond the Code / SBOM: Supply Chain Security
Anant Shrivastava (Founder · Cyfinoid Research)
Security BSides London 2023 · Day 1 · Track 2
Overview
In this insightful talk, "Beyond the Code / SBOM: Supply Chain Security," Anant Shrivastava, Founder of Cyfinoid Research, cuts through the industry hype surrounding software supply chain security. Shrivastava provides a critical perspective on what supply chain security truly entails, contrasting it with vendor-driven narratives and commercially pushed solutions. The presentation challenges the notion that this is an entirely new problem, instead framing it as a long-standing challenge that has recently gained significant commercial attention.

Key moments
- 7:00 Why software supply chain security is a buzzword now
- 16:20 Defining Software Bill of Materials (SBOM)
- 20:20 What SBOM cannot do (SolarWinds, code path relevance)
- 24:00 Historical dependency management: Vetted vs. Isolated software
- 28:30 Understanding Provenance and essential security frameworks
- 40:00 Essential questions to ask SBOM solution vendors
- 44:25 Q&A: How to prioritize vulnerabilities from scanner reports
Beyond the Code / SBOM: Supply Chain Security
Speakers: Anant Shrivastava, Founder, Cyfinoid Research
Conference: BSides London
YouTube: https://www.youtube.com/watch?v=30lIhTUpzOQ
Overview
In this insightful talk, "Beyond the Code / SBOM: Supply Chain Security," Anant Shrivastava, Founder of Cyfinoid Research, cuts through the industry hype surrounding software supply chain security. Shrivastava provides a critical perspective on what supply chain security truly entails, contrasting it with vendor-driven narratives and commercially pushed solutions. The presentation challenges the notion that this is an entirely new problem, instead framing it as a long-standing challenge that has recently gained significant commercial attention.
Shrivastava's expertise, spanning over 15 to 17 years across diverse roles from server administration to development and information security, allows him to offer a comprehensive and grounded view. He aims to provide attendees with a clear understanding of the current landscape, the genuine needs in this space, and actionable insights for practitioners. The talk is particularly relevant for anyone navigating the complexities of modern software development, aiming to build robust and trustworthy systems amidst a proliferation of third-party components and rapid release cycles.
Background
▶ Watch: Why software supply chain security is a buzzword now (7:00)
The concept of a supply chain is fundamentally about establishing trust in a multi-stage process, whether for physical goods or software. Shrivastava illustrates this with a traditional manufacturing analogy: raw materials become intermediate components, then semi-finished products, culminating in a final product like a laptop, which is then distributed to an end-user. Translating this to software, he identifies four primary entities: a producer (creating basic building blocks like third-party libraries, e.g., libcurl), a consumer (software manufacturers leveraging these libraries), infrastructure providers (storing artifacts like S3 buckets or Docker Hub), and the end-user (who uses the final software). This forms a complex, often cyclic, ecosystem.
From a development perspective, the software supply chain comprises six critical building blocks: the software developer, code repositories, CI/CD systems, containers, dependencies, and the service provider (e.g., Azure, AWS). Securing the supply chain necessitates a holistic view of this entire interconnected process. The fundamental challenge, as Shrivastava emphasizes, is to establish trust: "Can we trust the entire process that there is no problem in the entire process and we have received the final product good in handy?"
The notion of distrusting software is not new. Shrivastava references Ken Thompson's seminal 1984 Turing Award speech, "Reflections on Trusting Trust," which discussed compiler backdoors. Even earlier, a 1974 Air Force document is cited as the first written instance of considering how components of a software development process could be compromised to produce malicious output despite benign input. OWASP, too, has highlighted "Vulnerable and Outdated Components" since 2004. So, if the problem is decades old, what changed?
The recent surge in attention stems largely from high-profile incidents like SolarWinds, Colonial Pipeline, and Kaseya, which prompted a U.S. executive order. This order tasked NIST with developing a framework for securing U.S. government software, leading to the Secure Software Development Framework (SSDF). Concurrently, Google and others developed the Supply Chain Levels for Software Artifacts (SLSA) framework. These initiatives propelled two key industry buzzwords into the spotlight: Software Bill of Materials (SBOM) and Provenance.
The modern software development paradigm itself has exacerbated these issues. The relentless drive to automate and accelerate software builds and deployments, moving from waterfall to Agile and now to continuous releases (every hour, every 10 minutes), means manual checks are impossible. This automation, while increasing velocity, has several side effects: developers have less incentive to upgrade dependencies due as frequent updates become overwhelming (e.g., three library versions released in five days); and there's a significant reliance on open-source software where maintainers often have no service provider agreements yet bear the security burden. The traditional segregation of feature and stable (bugfix) releases has largely disappeared, creating a single, fast-moving stream that complicates dependency management for consumers.
Key Findings
▶ Watch: What SBOM cannot do (SolarWinds, code path relevance) (20:20)
Anant Shrivastava highlights several critical findings that challenge conventional wisdom and vendor narratives around software supply chain security. Firstly, he asserts that the problem of supply chain insecurity is not novel; it has existed for decades, as evidenced by historical documents and OWASP's long-standing warnings. What is new is the intense commercialization of solutions, driven by recent high-profile breaches and subsequent governmental mandates.
A core observation is the "80/20 rule" often cited by vendors: "80% of your code is not written by you." While true, Shrivastava adds a crucial caveat: a significant portion of that 80% might not even be used by the consuming application. Developers often import entire libraries for a small fraction of their functionality, inheriting the full spectrum of potential vulnerabilities without leveraging the problematic paths. This distinction is vital for accurate risk assessment.
The primary solution being pushed, the Software Bill of Materials (SBOM), is fundamentally an inventory tool. Shrivastava likens it to the "Identify" function in the NIST Cybersecurity Framework, emphasizing that "if you don't know your assets, you cannot protect them." SBOMs provide a list of ingredients, but they are not a panacea. A key finding is that while SBOMs are valuable for understanding components, they wouldn't have prevented incidents like the SolarWinds hack, which stemmed from a compromised CI system—an aspect not covered by standard SBOM specifications.
The current industry focus, largely dictated by what can be automated and productized, revolves around two main objectives: identifying and remediating outdated third-party dependencies, and creating and validating SBOMs and their Provenance. This narrow focus, Shrivastava argues, often leaves critical gaps unaddressed. The reality for developers is that maintaining up-to-date dependencies is a monumental task. The speaker shares an anecdote where a friend lamented the overwhelming number of Dependabot requests, unable to update due to potential regressions and lack of robust test coverage. Achieving 80-90% test coverage, he notes, remains a "utopian security dream" for most organizations, hindering automated updates and creating a persistent backlog of vulnerabilities.
Finally, Shrivastava points out that the industry is caught in a cycle of solving problems it created. The push for rapid automation led to complex dependency trees and overwhelming update burdens. Now, new tools and frameworks are emerging to manage these complexities, often driven by government mandates (like the U.S. executive order for SBOMs) rather than purely organic market demand. This continuous evolution, however, has also brought positive developments, such as the rise of "as-code" paradigms (Infrastructure-as-Code, Compliance-as-Code, Policy-as-Code) and advancements in cryptographic standards, which are crucial for establishing Provenance and overall trust.
Technical Deep Dive
▶ Watch: Historical dependency management: Vetted vs. Isolated software (24:00)
The technical core of the talk revolves around Software Bill of Materials (SBOMs), Provenance, and the frameworks and tools designed to secure the software supply chain.
An SBOM is essentially a list of ingredients for a software product. It typically includes the software name, version, cryptographic checksum, license information, and direct (one-level deep) dependencies. The idea is that a complete SBOM tree would be built by aggregating SBOMs from all constituent components. However, standard SBOMs have limitations; they typically do not contain information about the compiler used, integrated ML models, SAST services, or the operating system. Projects like OWASP CycloneDX are actively working to expand the scope of "bills of material," exploring concepts like Cryptographic Bill of Material to list cryptographic ingredients used across a codebase. Another crucial development is VEX (Vulnerability Exploitability eXchange), a specification aiming to detail which reported CVEs against dependencies are actually applicable or exploitable within a specific software product.
The primary utility of an SBOM is inventory management. It enables organizations to quickly query their environment to identify all software instances using a particular library when a CVE emerges (e.g., finding all uses of libcurl for a CVE-2023-XXXX with a 9.8 CVSS score, or identifying Log4j instances during the Log4Shell crisis, which some organizations took 45-50 days to do manually). This helps in rapid response to widespread vulnerabilities. However, as noted, SBOMs alone do not prevent all attacks, particularly those targeting the CI system, like SolarWinds.
Provenance is critical for establishing trust in SBOMs and other software artifacts. It's a cryptographically verifiable proof that a document or artifact is authentic and has not been tampered with. Shrivastava explains this by contrasting a simple checksum on a download page (which an attacker could also compromise) with a document independently signed by a trusted third party. This signed document, cryptographically tamper-proof, allows for independent verification of the artifact's authenticity, even if the primary download source is compromised. This independent verification capability is paramount.
Shrivastava briefly covers two foundational frameworks:
- SLSA (Supply Chain Levels for Software Artifacts): Developed by Google, SLSA defines maturity levels for supply chain security. It started ambitiously with four levels, aiming for "reproducible builds" at Level 4 (where identical source code processed by a known compiler produces bit-for-bit identical output). However, SLSA 1.0 has temporarily removed Level 4, recognizing its extreme difficulty in practice, focusing instead on practical steps across Levels 1-3. The framework envisions the entire software chain, from producer to consumer, identifying potential problem points and mitigation strategies.
- NIST SSDF (Secure Software Development Framework): This framework, created by NIST following the U.S. executive order, provides guidelines for secure software development. It's structured around four high-level areas: Prepare the Organization, Protect the Software, Produce Well-Secured Software, and Respond to Vulnerabilities. Shrivastava notes its alignment with the NIST Cybersecurity Framework (Identify, Protect, Detect, Respond, Recover). Critically, NIST SSDF aims to avoid creating yet another siloed standard by mapping its line items to existing frameworks like OWASP SAMM and PCI DSS, easing adoption for organizations already compliant with other standards.
Beyond these new frameworks, the talk also delves into historical approaches to managing third-party components, primarily in the open-source realm:
- Vetted Software (Centralized Approach): Exemplified by Linux distributions like Debian. Here, a single entity (the distro maintainers) takes ownership of a specific set of libraries, ensuring security updates and maintaining stable releases. The advantage is inherent stability and a single point of contact for security. The disadvantage is a restricted selection of available software and slower updates, as maintainers cannot support every new module.
- Isolated Software (Decentralized Approach): Common in ecosystems like Node.js (with its
node_modulesfolder) or Python (withpipandvenv). Each project effectively downloads and manages its own dependencies in an isolated environment, allowing developers to use specific versions without affecting other projects. This offers flexibility and access to the latest modules but places the burden of security updates and vulnerability management squarely on the individual developer, leading to "dependency hell" and often hundreds of nested dependencies.
Demo / Proof of Concept
▶ Watch: Essential questions to ask SBOM solution vendors (40:00)
Anant Shrivastava's talk is a detailed technical exposition and critical analysis of software supply chain security, rather than a live demonstration or proof of concept. While he references various tools and frameworks that enable practical application of these concepts, the presentation itself does not feature a live demo of a specific exploit, a tool in action, or a build process. Instead, it focuses on the theoretical underpinnings, practical challenges, and strategic approaches to securing the software supply chain.
Defensive Implications
▶ Watch: Q&A: How to prioritize vulnerabilities from scanner reports (44:25)
For defenders, Shrivastava provides clear, actionable guidance on navigating the complex landscape of software supply chain security. He advocates for a pragmatic approach, leveraging established frameworks and specific tools, while also exercising critical judgment, especially when evaluating vendor solutions.
Framework Adoption:
Defenders should familiarize themselves with and consider adopting frameworks like SLSA and NIST SSDF. Shrivastava particularly highlights NIST CSF Version 2 (currently in draft), noting its "Govern" section as crucial for crafting organizational governance policies. The SSDF's approach of mapping to existing standards (OWASP SAMM, PCI DSS) is beneficial, avoiding redundant efforts.
Leveraging Open-Source Tooling:
Several open-source tools are recommended for practical implementation:
- OSSF Scorecard: This tool can be integrated into CI/CD pipelines (e.g., GitHub, GitLab workflows). It acts as a "health stat" for software projects, identifying insecure practices in configurations, highlighting outdated dependencies, and flagging issues like the absence of code reviews (e.g., if maintainers merge pull requests without review).
- Sigstore and Cosign: Cosign is a container signing process that, as part of the broader Sigstore project, aims to establish Provenance. It creates a report of container ingredients and checksums, signs it, and makes it available, ensuring that "whatever you were supposed to get is what you got."
- SafeDep vet: A verification tool integrable into CI/CD or used standalone. It analyzes dependency trees for current state, drifts (how many versions behind), security bugs, and compliance issues. A powerful feature is the ability to define custom organizational rules, such as disallowing GPL-licensed dependencies, dependencies hosted on GitHub with no activity for six months, or those with fewer than 100 stars.
- Stacklok: A newer tool, also developed by the creators of Sigstore, that offers a Visual Studio Code plugin. As a developer types an
importstatement, Stacklok provides a rating for the module and, crucially, suggests alternative, higher-rated modules in the same functional sphere. While not 100% comprehensive, it provides a valuable starting point for making more secure dependency choices.
Critical Vendor Due Diligence:
Shrivastava urges defenders to ask probing questions to any vendor selling SBOM solutions, to move beyond superficial compliance and towards genuine security:
- "What do I do with the SBOM?": An SBOM is an inventory. The critical follow-up is understanding the next steps, the actionable intelligence derived from it. If a vendor claims "this is all you needed," it's a red flag.
- "Are you just spotting vulnerabilities based on version number, or are you actually validating that my code has that vulnerability?": Most vendors will only do version-based scanning. True validation (checking if the vulnerable code path is actually reachable and used) is a significantly harder problem, with no current tool offering 100% accuracy. Defenders should test this by introducing a known vulnerable dependency but ensuring the problematic code path is never invoked, then checking if the vendor's tool still flags it as an issue.
- "Do you have alternative solutions to the libraries?": Beyond identifying a vulnerable dependency, a truly valuable solution should guide developers towards safer alternatives, similar to what Stacklok attempts to do. This proactive guidance is often missing from proprietary tools.
Vulnerability Prioritization:
Recognizing that developers cannot fix thousands of reported vulnerabilities, defenders must prioritize effectively:
- Deep Dive: Go beyond the CVE score. Investigate if the problematic function or code path is actually used in the application.
- Scoring Systems:
- CVSS (Common Vulnerability Scoring System): Provides a general severity score.
- EPSS (Exploit Prediction Scoring System): Predicts the likelihood of a vulnerability being exploited in the wild.
- KEV (Known Exploited Vulnerabilities) Catalog: A list maintained by governmental agencies of vulnerabilities actively being exploited. Vulnerabilities in the KEV catalog demand immediate attention.
- Code Coverage: High test coverage (e.g., 80-90%) is a foundational step, enabling safer and more frequent dependency updates by quickly identifying regressions.
Key Takeaways
- Supply Chain Security is Not New, But Commercialized: The core problem of trusting software components has existed for decades, but recent high-profile breaches and government mandates have driven its commercialization, often with vendor narratives that oversimplify or misrepresent the issue.
- SBOMs are Essential Inventory, Not a Panacea: Software Bill of Materials are crucial for identifying components and responding to widespread CVEs (e.g., Log4j), fulfilling the "Identify" function of NIST CSF. However, they do not inherently prevent all attacks (e.g., CI system compromises) and require enhancements like VEX (Vulnerability Exploitability eXchange) to determine actual applicability of vulnerabilities.
- Provenance is Critical for Trust: Beyond mere inventory, cryptographically verifiable Provenance is necessary to ensure the authenticity and integrity of SBOMs and other software artifacts, providing independent assurance against tampering.
- Embrace Frameworks and Open-Source Tools: Leverage established frameworks like SLSA (Google) and NIST SSDF (which maps to existing standards like OWASP SAMM). Utilize powerful open-source tools such as OSSF Scorecard for CI health, Sigstore/Cosign for artifact signing, SafeDep vet for dependency verification with custom rules, and Stacklok for proactive secure module suggestions.
- Challenge Vendors with Specific Questions: Do not accept generic solutions. Demand answers to: "What do I do with the SBOM?", "Are you validating actual exploitability beyond version numbers?", and "Do you offer alternative, more secure libraries?".
- Prioritize Vulnerabilities Strategically: Given the overwhelming number of potential issues, prioritize remediation based on actual code path usage, CVSS scores, EPSS (Exploit Prediction Scoring System) for likelihood of exploitation, and especially the KEV (Known Exploited Vulnerabilities) catalog for actively exploited vulnerabilities.
About the Speaker(s)
Anant Shrivastava is the Founder of Cyfinoid Research, bringing a wealth of experience cultivated over 15 to 17 years in the corporate world. His diverse background spans various technical roles, including server administration, software development, and information security professional, before founding his own company. Anant is a frequent speaker and trainer at numerous conferences globally. He is also a prolific contributor to the open-source community, maintaining several projects such as Code Vigilant (focused on source code audits for open-source projects), the Tamer platform (dedicated to Android security), and Hacking Archives for India (a collection of information security conferences featuring Indian presenters). He can be found on social media at @anantshri.
Reviews
Dr. Zero (Offensive Security Researcher) — SOLID
Shrivastava spends his time dismantling the vendor-driven SBOM hype train, which alone makes this a decent watch. It doesn't drop novel research, but it serves as a brutally pragmatic reality check on why dumping CycloneDX XMLs into a dashboard won't save you from the next SolarWinds.
Heather Calloway (CISO) — STRONG ACCEPT
Shrivastava cuts through the compliance theater surrounding SBOMs and supply chain security. He correctly frames SBOMs as a basic inventory exercise rather than a protective control, giving leaders a much-needed reality check on what this tooling actually buys us. This is highly recommended for any CISO currently navigating the vendor hype cycle around software provenance.