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.
| Fase | Minaccia | Esempio |
|---|---|---|
| Sorgente | Modifica non autorizzata del codice | Commit malevolo senza code review |
| Build | Build da sorgente diverso o compromessa | Server di build manomesso che inietta una backdoor |
| Pubblicazione | Upload di un artefatto non prodotto dalla build ufficiale | Token del maintainer rubato e pacchetto caricato a mano |
| Dipendenze | Uso di una dipendenza compromessa | Libreria di terze parti avvelenata |
| Consumo | Installazione di un artefatto contraffatto | Modello 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
- Automatizza la build in un workflow CI, eliminando i rilasci manuali (L1).
- Sposta la build su una piattaforma ospitata e genera provenance firmata (L2).
- Usa un builder isolato, come i workflow riutilizzabili di
slsa-github-generator(L3). - 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
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.