# Software Supply Chain Security: What AI Coding Changes

## Executive summary

The modern software supply chain is vastly expanded, incorporating not only open-source dependencies and container base images but also continuous integration/deployment (CI/CD) pipelines and AI-generated code. This expansion increases the attack surface, as demonstrated by incidents like Log4j and SolarWinds. To mitigate risk, the video advocates for 'shifting left'—implementing security checks early in the development lifecycle. Key strategies include generating a Software Bill of Materials (SBOM), automating dependency scanning, verifying AI-generated code independently, and establishing verifiable software provenance using frameworks like SLSA.

## Key takeaways

- The Scope of the Supply Chain: The software supply chain includes the application, open-source packages, container base images, build pipelines, secrets, and AI-generated code. Most components are not written from scratch and are often unreviewed.
- The Need for Proactive Security: Security flaws can be difficult to remediate when embedded deep within dependencies (e.g., Log4j) or across hybrid cloud environments. Attacks can also occur through ecosystem poisoning (e.g., typosquatting on NPM/PyPI) or by compromising the build pipeline itself (e.g., SolarWinds).
- Shift Left Security: Security checks must be automated and performed as early as possible in the development process, ideally before code is pushed or signed off in the CI pipeline, allowing human or AI reviewers to focus on high-judgment activities.
- The Four Pillars of Supply Chain Security: Teams should implement four core practices: 1) Create an SBOM (Software Bill of Materials) to list all ingredients; 2) Check early and automatically for vulnerabilities and secrets; 3) Verify AI code independently (using separate models/sessions); and 4) Prove provenance by signing artifacts (using frameworks like SLSA).

## Technical details

- Software Bill of Materials (SBOM): An 'ingredient list' for an application, detailing all components and versions, which is crucial for quickly assessing impact during a vulnerability disclosure (e.g., Log4j).
- Dependency Risk & Ecosystem Poisoning: Risks include using vulnerable libraries (like Log4j, which allowed remote code execution) or falling victim to malicious packages uploaded via typosquatting on registries like NPM or PyPI.
- Build Pipeline Attacks: Attacks can target the build process itself, allowing malicious code (backdoors) to be automatically updated and distributed to many customers, even if the software provider is trusted (e.g., SolarWinds).
- AI Code Agents as Suppliers: AI models and agents are considered a new, fast 'supplier' in the supply chain. Because they generate code, they must be treated like any other dependency and subjected to rigorous checks.
- Provenance and SLSA: To prove where an application came from, artifacts and code must be signed. The SLSA framework from the Linux Foundation provides a structured way to record and document the approval and checking process.

## Practical implications

- Implement automated dependency scanning and secret checks early in the CI pipeline.
- Mandate the creation and maintenance of an SBOM for every application.
- Adopt a 'zero trust' approach when using AI code agents, ensuring that code generation and code review are performed by separate, independent models or sessions.
- Establish artifact signing and provenance tracking using established frameworks like SLSA.

## Topics

Software Supply Chain Security, CI/CD Security, SBOM, Dependency Management, AI Code Security, Provenance, IBM Technology, Linux Foundation

Source: https://www.youtube.com/watch?v=iv32wI3MBpw
