hacking A.I

SLSA: il framework per difendere la supply chain AI

SLSA spiegato: livelli, provenance e firma per difendere pacchetti e modelli AI.

SLSA (Supply-chain Levels for Software Artifacts, si pronuncia "salsa") è il framework di sicurezza della supply chain che permette di dimostrare come, dove e da quale codice è stato prodotto un software. Nato in Google e oggi gestito dalla OpenSSF, si applica anche ai sistemi di intelligenza artificiale, per pacchetti, container e modelli. Vediamo livelli, requisiti e come adottarlo passo per passo.

Cos'è SLSA e quale problema risolve

Scansioni e pinning, visti nell'articolo sulla difesa della supply chain AI, controllano cosa usiamo. Non rispondono però a una domanda fondamentale: l'artefatto che sto installando è davvero stato costruito dal codice sorgente che dichiara? Un attaccante che compromette il server di build può inserire codice malevolo in un pacchetto il cui sorgente su GitHub è perfettamente pulito.

SLSA risponde con un insieme di requisiti progressivi, organizzati in livelli, e con un documento verificabile chiamato provenance, che descrive l'origine di ogni artefatto. La versione 1.0 è stata pubblicata nel 2023 e il framework continua a evolvere con nuovi "track" dedicati ad aspetti diversi della supply chain.

Le minacce che SLSA copre

SLSA modella la supply chain come un percorso sorgente → build → pacchetto → consumo e individua i punti in cui può essere attaccata.

Principali minacce alla supply chain secondo SLSA
FaseMinacciaEsempio
SorgenteModifica non autorizzata del codiceCommit malevolo senza code review
BuildBuild da sorgente diverso o compromessaServer di build manomesso che inietta una backdoor
PubblicazioneUpload di un artefatto non prodotto dalla build ufficialeToken del maintainer rubato e pacchetto caricato a mano
DipendenzeUso di una dipendenza compromessaLibreria di terze parti avvelenata
ConsumoInstallazione di un artefatto contraffattoModello sostituito su un mirror

I livelli SLSA del Build track

Il cuore di SLSA è il Build track, che prevede quattro livelli. Ogni livello aggiunge garanzie rispetto al precedente.

L0Nessuna garanzia

Situazione di partenza: nessuna provenance, nessun controllo sul processo di build.

L1Provenance esistente

La build è scriptata e produce una provenance che descrive come è stato creato l'artefatto. Aiuta contro gli errori, non contro un attaccante.

L2Build su piattaforma ospitata

La build gira su una piattaforma gestita (es. GitHub Actions) che firma la provenance. Impedisce la falsificazione dopo la build.

L3Build rafforzata

Build isolate tra loro e chiavi di firma inaccessibili ai passi definiti dall'utente. Protegge anche da manomissioni durante la build.

Provenance e attestazioni

La provenance è un documento firmato, nel formato in-toto attestation, che lega un artefatto (tramite il suo hash) alle informazioni su come è stato prodotto: repository, commit, workflow, piattaforma di build, parametri.

{
  "_type": "https://in-toto.io/Statement/v1",
  "subject": [{
    "name": "acme_ml-1.4.0-py3-none-any.whl",
    "digest": { "sha256": "9f2c...e81a" }
  }],
  "predicateType": "https://slsa.dev/provenance/v1",
  "predicate": {
    "buildDefinition": {
      "buildType": "https://actions.github.io/buildtypes/workflow/v1",
      "externalParameters": {
        "workflow": { "repository": "https://github.com/acme/acme-ml",
                      "ref": "refs/tags/v1.4.0" }
      }
    },
    "runDetails": {
      "builder": { "id": "https://github.com/slsa-framework/slsa-github-generator/..." }
    }
  }
}

Chi consuma il pacchetto può verificare la firma e controllare che l'artefatto provenga dal repository e dal tag attesi. Ecosistemi come npm (npm publish --provenance) e PyPI (attestazioni basate su Sigstore) supportano già questo meccanismo.

SLSA per l'intelligenza artificiale

Nei sistemi AI gli "artefatti" non sono solo pacchetti software, ma anche modelli addestrati e dataset. I principi di SLSA si applicano allo stesso modo:

  • Training come build: l'addestramento è una build il cui input è codice + dati + iperparametri e il cui output sono i pesi. La provenance deve registrare commit del codice, hash del dataset e ambiente di training.
  • Firma dei modelli: progetti OpenSSF come model-signing (basato su Sigstore) permettono di firmare i file del modello e verificarli prima del caricamento.
  • AI-BOM: formati come CycloneDX ML-BOM descrivono modelli e dataset usati, complementari alla provenance.
  • Pipeline di fine-tuning su runner gestiti e isolati, come richiesto dal livello L3.
  • Verifica all'ingresso: in produzione si caricano solo modelli con firma valida e provenance proveniente dalla pipeline autorizzata.

Come adottare SLSA: esempio pratico

  1. Automatizza la build in un workflow CI, eliminando i rilasci manuali (L1).
  2. Sposta la build su una piattaforma ospitata e genera provenance firmata (L2).
  3. Usa un builder isolato, come i workflow riutilizzabili di slsa-github-generator (L3).
  4. Verifica sempre la provenance lato consumatore, prima del deploy.

Generare la provenance con GitHub Actions

jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
      hashes: ${{ steps.hash.outputs.hashes }}
    steps:
      - uses: actions/checkout@<sha>
      - run: python -m build
      - id: hash
        run: echo "hashes=$(sha256sum dist/* | base64 -w0)" >> "$GITHUB_OUTPUT"

  provenance:
    needs: [build]
    permissions:
      actions: read
      id-token: write
      contents: write
    uses: slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@v2.1.0
    with:
      base64-subjects: "${{ needs.build.outputs.hashes }}"

Verificare prima dell'uso

slsa-verifier verify-artifact acme_ml-1.4.0-py3-none-any.whl \
  --provenance-path acme_ml.intoto.jsonl \
  --source-uri github.com/acme/acme-ml \
  --source-tag v1.4.0

Se l'artefatto è stato modificato o non proviene dal repository atteso, la verifica fallisce e il deploy si blocca.

Domande frequenti

No, è un framework volontario. È però sempre più citato da linee guida governative e da requisiti dei clienti come prova concreta di una supply chain sicura.

La SBOM elenca gli ingredienti (le dipendenze); la provenance descrive la ricetta e la cucina (come, dove e da quale sorgente è stato costruito l'artefatto). Sono complementari.

Per progetti ospitati su GitHub il costo è basso: i generatori ufficiali e Sigstore sono gratuiti. Lo sforzo principale è eliminare i rilasci manuali e introdurre la verifica nel processo di deploy.

Conclusione

Il framework SLSA trasforma la sicurezza della supply chain da una questione di fiducia a una questione di prove verificabili. Applicato a pacchetti, container e modelli di intelligenza artificiale, permette di sapere con certezza da dove arriva ciò che va in produzione e di bloccare tutto ciò che non ha un'origine dimostrabile.

Livio Bollini
Walter Livio Bollini

Matematico & Informatico · Intelligenza Artificiale · Sviluppo Web