The AI supply chain: AIBOMs, provenance and confidential computing
In this lesson you will:
- Describe the stages of the AI supply chain and the risks at each
- Explain SBOMs and AI bills of materials and what an AIBOM records
- Assess risks of foundation, pre-trained and open models and public datasets
- Verify provenance and authenticity of models and data
- Explain trusted execution environments, confidential computing and data-centre considerations
An AI system is assembled from parts made by many hands: datasets scraped or licensed, foundation models trained by others, adapters from public hubs, libraries, serving runtimes and accelerators. Any of them can carry a defect or a deliberate compromise.
1. The AI supply chain
| Stage | Example components | Risks |
|---|---|---|
| Data sources | Web crawls, licensed corpora, public datasets, synthetic data | Poisoning, copyright and licensing, personal data, unknown provenance |
| Pre-training | Foundation model developer | Undisclosed data, embedded bias, backdoors, safety gaps |
| Distribution | Model hubs, vendor downloads | Tampered weights, malicious serialisation, typosquatted model names |
| Adaptation | Fine-tunes, LoRA adapters, embeddings models | Poisoned adapters, safety regression, licence conflicts |
| Software | ML frameworks, serving runtimes, orchestration libraries, plugins, MCP servers | Vulnerable dependencies, malicious packages |
| Hardware and hosting | Accelerators, drivers, cloud services | Firmware flaws, shared-tenancy exposure, provider compromise |
2. SBOMs and AIBOMs
A software bill of materials (SBOM) lists the software components and versions in a product, so you can find affected systems when a vulnerability is announced. Formats include SPDX and CycloneDX.
An AI bill of materials (AIBOM) extends this to AI-specific components. Recent versions of both SPDX and CycloneDX include fields for models and datasets.
An AIBOM typically records:
- Models — name, version, provider, hash, licence, base model and fine-tuning lineage, intended use, model card link.
- Datasets — sources, versions, licences, collection dates, personal-data status, preprocessing.
- Software — frameworks, serving runtime, orchestration libraries, plugins/MCP servers, with versions.
- Hardware and services — accelerator types, hosting region, external APIs.
- Provenance and attestations — signatures, build information, evaluation results.
Use AIBOMs in procurement (ask vendors for them), in vulnerability management (map advisories to systems) and in incident response (what else uses this model?).
3. Foundation, pre-trained and open models
Using a model someone else trained means inheriting decisions you cannot see.
- Opaque training data — you may not know what was included, including copyrighted or personal data.
- Hidden behaviours — backdoors that activate on specific triggers are hard to detect by normal testing.
- Safety and bias characteristics — tuned for the provider's priorities, not yours.
- Licence terms — open-weight licences vary: some restrict commercial use, user counts or fields of use.
- Continuity — providers deprecate models; open projects may stop being maintained.
- Concentration — many organisations depend on a few foundation models, so one flaw can be widespread.
For public and open datasets, assess source reputation, licence, collection method, personal data, known contamination and whether the dataset has been modified since publication.
4. Provenance and authenticity verification
Pedigree is where something came from; provenance is the documented chain of custody since. Verify both.
- Download models only from approved sources and verified publishers; mirror approved artefacts into an internal registry.
- Cryptographic hashing — compare the artefact's hash with the publisher's.
- Digital signatures — verify signed models and datasets (for example using Sigstore-style signing) and build attestations.
- Prefer safe serialisation formats that cannot execute code on load; scan artefacts for embedded code.
- Record lineage: which base model, which dataset version, which fine-tune run produced which artefact.
- Evaluate before use: run your own safety, security and performance evaluations, not just the provider's.
Worked example — approving an open-weight model from a public hub
A team wants to use a popular open-weight model plus a community LoRA adapter for a legal-summarisation tool.
| Check | Result | Decision |
|---|---|---|
| Publisher verified on the hub? | Base model: yes. Adapter: individual account, 3 weeks old | Base model OK; adapter not approved |
| Hash matches publisher's release notes? | Yes for base model | OK |
| Format | Base: safe tensor format. Adapter: pickle-based | Adapter blocked — can execute code on load |
| Licence | Base model licence permits commercial use under a user threshold | Legal confirms within limits |
| Own evaluation | Base model passes the team's summarisation and injection tests | OK for Tier 2 use |
| AIBOM entry | Created with model hash, licence, evaluation results | Registered in inventory |
Outcome: base model approved and mirrored into the internal registry; the team fine-tunes its own adapter on vetted data instead of using the community one.
5. Confidential computing and data-centre considerations
When sensitive data or valuable model weights are processed on infrastructure you do not fully control, confidential computing reduces exposure.
- A trusted execution environment (TEE) is a hardware-isolated area of a processor (CPU and, increasingly, GPU) where code and data are protected from the host operating system, hypervisor and cloud operator.
- Remote attestation proves to a relying party what code is running in the TEE before secrets (such as decryption keys) are released to it.
- Uses for AI: protecting prompts and sensitive inference data; protecting proprietary model weights deployed at a customer or partner site; collaborative training on pooled data without exposing each party's data.
- Limitations: performance overhead, side-channel research, and trust in the hardware vendor's attestation chain.
Other data-centre considerations for third-party AI hosting: data residency of inference and logs; tenant isolation for accelerators; physical security and environmental resilience of high-density AI facilities; and the provider's own supply-chain controls.
🔐 Security lens
Treat a model file like an executable from the internet: verify the publisher, check the hash or signature, prefer non-executable formats, scan it, and keep an approved internal copy. Then record it in the AIBOM.
Key takeaways
- The AI supply chain spans data, pre-training, distribution, adaptation, software and hardware — each a point of failure.
- AIBOMs extend SBOMs with models, datasets, lineage, licences and attestations.
- Foundation and open models bring opaque data, hidden behaviours, licence terms and concentration risk.
- Verify pedigree and provenance with approved sources, hashes, signatures, safe formats and your own evaluations.
- TEEs and attestation protect data and weights in use; they reduce but do not eliminate trust in the provider and hardware.
Self-check
- What does an AIBOM add to a traditional SBOM?
- Why is a pickle-based adapter file from an unknown publisher a security concern?
- What does remote attestation prove, and to whom?