hacking A.I

Supply chain AI: come difenderla, con metodo

Difendere la supply chain AI: vetting del codice, scansioni, dependency confusion e pinning.

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.

Gli anelli della supply chain AI e i relativi rischi
ComponenteEsempiRischio principale
Pacchetti softwarePyPI, npm, condaPacchetti malevoli, typosquatting, dependency confusion
Modelli pre-addestratiHugging Face, model zooFile pickle che eseguono codice al caricamento, backdoor nei pesi
DatasetDataset pubblici, scraping webData poisoning
Build e CI/CDGitHub Actions, runner, registryManomissione degli artefatti, furto di segreti
ContainerImmagini base CUDA, PythonVulnerabilità 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 pickle usato 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 torchtriton malevolo 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 abilitare trust_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.

Strumenti open source di scansione per progetti AI
ObiettivoStrumenti
Dipendenze Pythonpip-audit, osv-scanner
Container e filesystemTrivy, Grype
Generazione SBOMSyft, CycloneDX
File di modelloModelScan, picklescan, fickling
Aggiornamenti automaticiDependabot, 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

  1. Un solo indice: in pip usare --index-url verso un proxy interno, mai --extra-index-url, che mescola le sorgenti.
  2. Registry proxy (Artifactory, Nexus, devpi) con regole che risolvono i nomi interni solo dal repository privato.
  3. Namespace e scope: in npm usare pacchetti con scope (@acme/...) associati al registry privato.
  4. Prenotare i nomi interni anche sui registry pubblici con pacchetti segnaposto.
  5. 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,
)

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

Può esserlo se il modello è in formato pickle o richiede trust_remote_code=True. Preferisci safetensors, fissa la revisione e scansiona i file prima di caricarli.

No. Il pinning blocca i cambiamenti inattesi, ma se fissi una versione già malevola o vulnerabile la mantieni. Serve abbinarlo a vetting e scansioni.

Il typosquatting usa nomi simili a pacchetti famosi (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.

Livio Bollini
Walter Livio Bollini

Matematico & Informatico · Intelligenza Artificiale · Sviluppo Web