La supply chain dell'intelligenza artificiale è l'insieme di librerie, framework, modelli pre-addestrati, dataset e pipeline di build da cui dipende ogni applicazione AI. Basta un solo anello compromesso per avvelenare l'intero sistema. In questo articolo vediamo perché difenderla è prioritario e con quale metodo: vetting automatico del codice di terze parti, scansione delle vulnerabilità, mitigazione della dependency confusion e dependency pinning.
Cos'è la supply chain dell'intelligenza artificiale
Un'applicazione AI moderna contiene pochissimo codice scritto "in casa". Il resto arriva da fuori: framework come PyTorch o TensorFlow, librerie come Transformers o LangChain, centinaia di dipendenze transitive, modelli scaricati da hub pubblici, dataset, immagini Docker e GitHub Actions. Ognuno di questi elementi è un fornitore, e ognuno può essere un punto d'ingresso per un attaccante.
| Componente | Esempi | Rischio principale |
|---|---|---|
| Pacchetti software | PyPI, npm, conda | Pacchetti malevoli, typosquatting, dependency confusion |
| Modelli pre-addestrati | Hugging Face, model zoo | File pickle che eseguono codice al caricamento, backdoor nei pesi |
| Dataset | Dataset pubblici, scraping web | Data poisoning |
| Build e CI/CD | GitHub Actions, runner, registry | Manomissione degli artefatti, furto di segreti |
| Container | Immagini base CUDA, Python | Vulnerabilità note, immagini modificate |
Le ragioni: perché la supply chain AI è un bersaglio
- Effetto moltiplicatore: compromettere una libreria popolare significa colpire migliaia di progetti in un colpo solo.
- I modelli sono codice: il formato
pickleusato da molti checkpoint PyTorch può eseguire istruzioni arbitrarie durante il caricamento. Scaricare un modello equivale a eseguire un programma. - Ambienti ricchi di segreti: le macchine di training e i notebook contengono chiavi cloud, token API e accesso a dati sensibili.
- Casi reali: a fine 2022 la build nightly di PyTorch ha installato un pacchetto
torchtritonmalevolo pubblicato su PyPI, un caso classico di dependency confusion; sugli hub pubblici sono stati più volte trovati modelli con payload nascosti. - Slopsquatting: gli assistenti di programmazione a volte "inventano" nomi di pacchetti inesistenti; gli attaccanti registrano proprio quei nomi sperando che qualcuno li installi.
- Normative: AI Act, NIS2 e Cyber Resilience Act chiedono tracciabilità dei componenti e gestione delle vulnerabilità.
Il metodo di difesa in 5 fasi
Una difesa efficace non è un singolo strumento ma un processo ripetibile, integrato nella pipeline e quindi automatico.
1. Inventario
Generare una SBOM (e una AI-BOM per modelli e dataset) per sapere cosa si usa davvero.
2. Vetting
Valutare ogni nuova dipendenza prima che entri nel progetto.
3. Scansione
Cercare vulnerabilità note e codice malevolo in pacchetti, container e modelli.
4. Blindatura
Pinning delle versioni, hash, registry controllati, protezione dei namespace.
5. Verifica della provenienza
Firme e attestazioni secondo il framework SLSA.
Automatizzare il vetting del codice di terze parti
Il vetting è la valutazione di affidabilità di una dipendenza. Fatto a mano non scala: un progetto AI può avere oltre 300 dipendenze transitive. Va quindi trasformato in regole automatiche che bloccano la pull request quando non sono rispettate.
Cosa controllare
- Salute del progetto: manutentori attivi, frequenza dei rilasci, branch protetti, code review. OpenSSF Scorecard calcola automaticamente un punteggio da 0 a 10.
- Comportamento sospetto: script di installazione, accesso alla rete, offuscamento, lettura di variabili d'ambiente. Strumenti come GuardDog o Socket analizzano il pacchetto prima dell'installazione.
- Età e popolarità: un pacchetto pubblicato ieri, con nome simile a uno famoso, è un campanello d'allarme.
- Licenza compatibile con l'uso previsto.
- Per i modelli: preferire il formato
safetensors, non abilitaretrust_remote_code, verificare l'organizzazione che pubblica.
Esempio: policy automatica con OpenSSF Scorecard
# controlla il punteggio di sicurezza di un repository
scorecard --repo=github.com/huggingface/transformers --format=json \
| jq '.score'
# analisi euristica di un pacchetto PyPI prima di installarlo
guarddog pypi scan nome-pacchetto
La regola tipica: ogni nuova dipendenza passa da un controllo automatico in CI; se il punteggio è sotto una soglia o emergono comportamenti sospetti, serve l'approvazione esplicita del team di sicurezza.
Scansioni delle vulnerabilità
Il vetting decide cosa entra; le scansioni controllano nel tempo che ciò che è entrato non sia diventato vulnerabile. Le scansioni vanno eseguite a ogni build e periodicamente, perché le nuove CVE vengono pubblicate ogni giorno.
| Obiettivo | Strumenti |
|---|---|
| Dipendenze Python | pip-audit, osv-scanner |
| Container e filesystem | Trivy, Grype |
| Generazione SBOM | Syft, CycloneDX |
| File di modello | ModelScan, picklescan, fickling |
| Aggiornamenti automatici | Dependabot, Renovate |
# vulnerabilità note nelle dipendenze
pip-audit -r requirements.txt
# immagine Docker: fallisce se trova CVE critiche o alte
trivy image --severity CRITICAL,HIGH --exit-code 1 mia-app-ai:latest
# modello scaricato: cerca operatori pickle pericolosi
modelscan -p ./models/checkpoint.bin
Un consiglio pratico: definire una soglia di blocco (es. nessuna vulnerabilità critica con fix disponibile) invece di bloccare tutto, altrimenti il team inizierà a ignorare gli allarmi.
Mitigazione della dependency confusion
La dependency confusion sfrutta il modo in cui i package manager scelgono tra registry privati e pubblici. Se un'azienda usa un pacchetto interno chiamato acme-ml-utils e un attaccante pubblica su PyPI un pacchetto con lo stesso nome e un numero di versione più alto, il package manager può preferire quello pubblico. L'attacco è stato reso noto nel 2021 dal ricercatore Alex Birsan, che lo ha usato con successo contro decine di grandi aziende.
Contromisure
- Un solo indice: in pip usare
--index-urlverso un proxy interno, mai--extra-index-url, che mescola le sorgenti. - Registry proxy (Artifactory, Nexus, devpi) con regole che risolvono i nomi interni solo dal repository privato.
- Namespace e scope: in npm usare pacchetti con scope (
@acme/...) associati al registry privato. - Prenotare i nomi interni anche sui registry pubblici con pacchetti segnaposto.
- Hash obbligatori: un pacchetto sostituito ha un hash diverso e l'installazione fallisce.
# pip.conf - un unico indice: il proxy aziendale
[global]
index-url = https://pypi.acme.internal/simple
require-hashes = true
# .npmrc - lo scope aziendale punta solo al registry privato
@acme:registry=https://npm.acme.internal/
Dependency pinning
Il dependency pinning consiste nel fissare la versione esatta, e idealmente l'hash, di ogni dipendenza. Senza pinning, torch>=2.0 può installare oggi una versione e domani un'altra, magari compromessa. Il pinning rende le build riproducibili e impedisce che un aggiornamento malevolo entri in modo silenzioso.
Cosa "pinnare" in un progetto AI
# 1. Pacchetti Python con hash (pip-tools o uv)
pip-compile --generate-hashes requirements.in
pip install --require-hashes -r requirements.txt
# 2. Immagini Docker per digest, non per tag
FROM python:3.12-slim@sha256:<digest>
# 3. GitHub Actions per commit SHA, non per tag
- uses: actions/checkout@<sha-completo-del-commit>
# 4. Modelli Hugging Face per revisione
model = AutoModel.from_pretrained(
"org/modello",
revision="<commit-sha>",
use_safetensors=True,
)
tj-actions/changed-files ha spostato i tag di versione su codice malevolo. Chi aveva fatto il pinning per SHA non è stato colpito.
Il pinning ha un costo: le versioni invecchiano. Per questo va abbinato a Dependabot o Renovate, che propongono aggiornamenti come pull request controllate, sottoposte di nuovo a vetting e scansione.
Esempio: una pipeline CI che mette tutto insieme
name: supply-chain-check
on: [pull_request]
permissions:
contents: read
jobs:
security:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@<sha>
- name: Installazione con hash obbligatori
run: pip install --require-hashes -r requirements.txt
- name: Vulnerabilità note
run: pip-audit -r requirements.txt
- name: Scansione modelli
run: pip install modelscan && modelscan -p ./models
- name: SBOM
run: syft dir:. -o cyclonedx-json > sbom.json
Il passo successivo è dimostrare da dove arriva ogni artefatto prodotto: è il compito del framework SLSA.
Domande frequenti
pickle o richiede trust_remote_code=True. Preferisci safetensors, fissa la revisione e scansiona i file prima di caricarli.reqeusts), contando su un errore di battitura. La dependency confusion usa lo stesso nome di un pacchetto interno, sfruttando la logica di risoluzione del package manager.Conclusione
Difendere la supply chain dell'intelligenza artificiale significa trattare ogni libreria, modello e dataset come codice di terzi da verificare. Vetting automatico, scansioni continue, protezione dalla dependency confusion e dependency pinning formano una prima linea di difesa concreta, economica e automatizzabile.