Executive summary
Enterprises delivering AI‑enabled features face two intertwined supply‑chain challenges: traditional software component risk and the provenance of the model itself. A software bill of materials (SBOM) inventories code, libraries, containers and firmware, but does not prove where model weights or training data originated. Complementary controls such as model cards, cryptographic signing, and SLSA build attestations can reduce uncertainty, yet no universal model‑signing standard exists. This article explains the technical foundations, architecture, implementation steps, governance implications and operational trade‑offs for securing the AI software supply chain.
Introduction
Artificial intelligence is no longer a research curiosity; it is embedded in products ranging from recommendation engines to autonomous control loops. As AI moves into production, organizations must treat the model, its adapters, and the surrounding software as a single supply chain. The United States Cybersecurity and Infrastructure Security Agency (CISA) recently released a Minimum Elements specification for software bills of materials (SBOM) [1] and a supplemental guidance for AI‑specific SBOMs [2]. At the same time, the OWASP Gen AI Security Project warns that model provenance remains weak and that adapters can introduce malicious behavior [4]. SLSA version 1.2 defines build‑track levels that attest to the integrity of the build process [3]. This article walks through each of these elements, shows how they interoperate, and identifies gaps that must be managed through policy and process.
Technical fundamentals
SBOM basics
CISA defines an SBOM as a nested inventory that lists every component used to assemble a software system. The 2026 Minimum Elements document enumerates baseline data fields such as component name, version, hash value, hash algorithm and a generation context that records the lifecycle phase when the SBOM was produced [1]. Coverage is expected to be exhaustive, including transitive dependencies, with no prescribed depth limit. The SBOM must be machine‑processable and updated for every new version, build or correction.
Model provenance vs. model signing
SBOMs cover the software side but do not capture the origin of model weights, the training data, or the safety properties retained after fine‑tuning. The OWASP LLM03 entry notes that no universally accepted model‑signing standard exists; instead, practitioners rely on integrity checks (hashes) and code signing for the surrounding code [4]. Model cards provide documentation of intended use, data sources and evaluation metrics, but they are not cryptographic guarantees.
SLSA build‑track levels
SLSA (Supply‑Chain Levels for Software Artifacts) defines four build levels. Level 0 has no requirements; Level 1 requires that provenance be generated and distributed, but it can be forged. Level 2 demands a hosted platform that signs the provenance, making casual tampering harder. Level 3 requires a hardened platform that isolates the build environment and protects signing secrets, offering strong confidence that the artifact originated from the declared source [3]. These levels speak to the integrity of the build process; they do not certify the correctness of training data or the absence of malicious adapters.
Architecture and components
The AI supply‑chain architecture consists of two parallel tracks that converge at deployment:
- Software track – source code, third‑party libraries, container bases, firmware, CI/CD pipelines. An SBOM is generated for each build.
- Model track – base model weights, adapters, fine‑tuning scripts, training data snapshots, model cards. Provenance records may be created using SLSA level 2 or 3 builds, and hash values are stored alongside the SBOM.
The diagram below illustrates the two tracks and their convergence.
flowchart LR
subgraph Software Track
A[Source Code] --> B[Build System]
B --> C[Container Image]
C --> D[SBOM Generation]
end
subgraph Model Track
E[Base Model Weights] --> F[Adapter Integration]
F --> G[Fine‑tuning Pipeline]
G --> H[Model Artifact]
H --> I[Model Provenance Record]
end
D --> J[Deploy Service]
I --> J
style Software\ Track fill:#e3f2fd,stroke:#2196f3
style Model\ Track fill:#ffebee,stroke:#e53935
Detailed implementation approach
- Establish SBOM generation policy – Use CISA’s minimum elements as the baseline. Automate SBOM creation with tools that output CycloneDX or SPDX, ensuring inclusion of transitive dependencies, hashes, and generation context.
- Create model provenance records – Treat the model artifact as a package. Run the fine‑tuning pipeline on a platform that supports SLSA level 2 or 3, capture the build provenance JSON, and store a cryptographic hash of the final weight file.
- Link SBOM and model record – Extend the SBOM with a custom field that references the model provenance identifier (e.g., a UUID). This cross‑reference enables downstream consumers to retrieve both software and model inventories from a single manifest.
- Validate at deployment – A gate in the CI/CD pipeline fetches the SBOM and model provenance, verifies hashes against known good values, and checks that any “unknown” fields are explicitly marked. If verification fails, the deployment is halted.
- Continuous monitoring – Subscribe to vulnerability feeds for both software components and known model‑related CVEs. When a new advisory is published, the SBOM can be re‑evaluated for impact.
Architecture and data‑flow
The data flow can be broken into four phases:
- Ingestion – Pull third‑party libraries from package registries, pull base models from trusted repositories, and record their metadata.
- Build – Compile code, assemble containers, run fine‑tuning. Generate SBOM and model provenance concurrently.
- Release – Publish the container image to an internal registry, attach the SBOM and model provenance as artifacts, and register them in a supply‑chain registry.
- Consume – At runtime, the service reads the attached SBOM and provenance, validates signatures, and logs the result for audit.
Security and governance
Alignment with NIST AI RMF
The NIST AI Risk Management Framework calls for traceability and auditability of AI components. SBOMs satisfy the traceability of software; model provenance satisfies traceability of AI assets. Together they support the NIST AI RMF’s “Governance” and “Risk Management” functions.
Controls
- Hash verification – Component hash algorithm and value must be recorded; unknown values are explicitly flagged.
- Signed provenance – Use SLSA level 2 or 3 to sign the provenance record, reducing the risk of forgery.
- Access controls – Restrict who can publish SBOMs or model records; require multi‑factor authentication for signing keys.
- Policy enforcement – Automated checks reject any artifact that lacks a complete SBOM or model provenance, or that contains an “unknown” component without justification.
Enterprise use cases
- Regulated finance – A bank must demonstrate that its credit‑scoring model does not rely on prohibited data. By linking the SBOM to a model provenance record that cites the data‑origin note, auditors can verify compliance.
- Healthcare AI – A hospital deploys a diagnostic model. The SBOM ensures that all third‑party libraries are up to date, while the model provenance includes a signed statement that the training data were de‑identified according to HIPAA.
- Edge devices – An IoT vendor ships a camera with an on‑device object‑detection model. The device’s firmware includes an SBOM; the model weight file is verified against a hash stored in the SBOM at boot time, preventing a malicious adapter from being swapped in.
Benefits and limitations
| Aspect | What the artifact attests | What it does not prove |
|---|
| SBOM (CISA minimum) | Complete list of software components, versions, hashes, generation context | Origin of model weights, training data provenance, safety property preservation |
| SLSA level 2 | Build provenance signed by a hosted platform; prevents casual tampering | Guarantees that source data or model training process were trustworthy |
| SLSA level 3 | Hardened build environment; strong confidence in build integrity | Does not verify that adapters are benign or that training data were clean |
| Model provenance record (custom) | Hash of weight file, adapter identifiers, signed metadata | Universal proof of where every training example came from |
Operational considerations
- Tooling integration – SBOM generators must be part of the CI pipeline; SLSA‑compatible build platforms (e.g., Google Cloud Build, GitHub Actions with SLSA support) are required for higher levels.
- Storage – SBOMs and provenance records should be stored in an immutable artifact registry with versioning.
- Performance – Verifying hashes at runtime adds latency; caching verified results mitigates impact.
- Incident response – When a vulnerability is disclosed, the SBOM enables rapid impact analysis. Missing components or “unknown” fields signal the need for deeper investigation.
Best practices
- Generate SBOMs for every release – Follow CISA frequency guidance: each software version, update or correction triggers a new SBOM.
- Mark unknown fields explicitly – Use the “unknown‑information practice” to indicate when a hash or source is not available, allowing consumers to treat the SBOM as incomplete.
- Adopt SLSA level 3 for high‑value models – When the model influences critical decisions, invest in a hardened build platform.
- Version model artifacts – Treat each fine‑tuned model as a separate package with its own SBOM entry and provenance record.
- Audit adapters – Maintain a separate SBOM subsection for adapters; verify their hashes and provenance before integration.
Analysis
The combination of CISA’s SBOM minimum elements, the supplemental AI SBOM guidance, and SLSA build‑track levels provides a layered defense. SBOMs give visibility into software dependencies, while signed provenance and hash verification give confidence that the exact artifacts deployed match those recorded. However, the ecosystem still lacks a universal, cryptographically verifiable model‑signing standard. Consequently, organizations must rely on compensating controls such as model cards, restricted sourcing, and rigorous adapter vetting. The gap is most acute for transitive model dependencies (e.g., low‑rank adapters) that can alter behavior without changing the base weight hash.
What the sources do not settle
- Universal model‑signing – No source defines a standard that can be applied across all AI frameworks to certify model provenance.
- Full coverage of training data – The CISA SBOM elements and SLSA specifications stop at component inventory; they do not provide a mechanism to enumerate or validate each training example.
- Legal enforceability – While the CISA documents are guidance, they do not constitute mandatory regulation, leaving compliance interpretations to individual organizations.
Conclusion
Securing the AI software supply chain requires a blend of established software‑SBOM practices, emerging AI‑specific inventory guidance, and strong build‑track attestations. By generating complete SBOMs, linking them to signed model provenance records, and adopting SLSA level 3 where risk justifies the investment, enterprises can make risk‑informed decisions and satisfy governance frameworks such as NIST’s AI RMF. The remaining gaps—most notably the absence of a universal model‑signing standard and the inability to prove training‑data provenance—must be managed through policy, sourcing discipline and continuous monitoring.
References
[1] https://www.cisa.gov/sites/default/files/2026-07/2026_cisa_sbom_minimum_elements_508c.pdf
[2] https://www.cisa.gov/resources-tools/resources/software-bill-materials-ai-minimum-elements
[3] https://slsa.dev/spec/v1.2/build-track-basics
[4] https://genai.owasp.org/llmrisk/llm032025-supply-chain/
These published CloudExchangers articles are further desk reading. They are not sources for the technical claims above.