Comment implémenter SLSA en 2026 (Guide beginner)

Introduction

SLSA (Supply-chain Levels for Software Artifacts) est un framework open-source conçu pour sécuriser les chaînes d'approvisionnement logicielles contre les attaques comme les injections de code malveillant ou les compromissions de dépendances. Développé par Google et adopté par des géants comme GitHub, il définit des niveaux de maturité (1 à 4) pour garantir la tamper-evidence (impossible à altérer sans détection) et la transparence des builds.

Pourquoi l'implémenter en 2026 ? Les incidents comme SolarWinds ou Log4Shell ont montré les risques des supply chains. SLSA niveau 1, accessible aux débutants, protège déjà 80% des menaces courantes en rendant vos artefacts (binaires, conteneurs) vérifiables via des attestations de provenance cryptographiques. Ce tutoriel vous guide pas à pas pour un projet Go simple sur GitHub Actions : du setup au build sécurisé. Résultat : un workflow produisant un binaire + provenance SLSA, vérifiable publiquement. Idéal pour freelances ou startups en DevSecOps. (142 mots)

Prérequis

Compte GitHub gratuit
Git installé localement
Go 1.21+ (optionnel, pour tests locaux ; Actions l'installe)
Connaissances basiques GitHub (push/pull)
10 minutes pour un repo test

Initialiser le projet Go

setup.sh

mkdir slsa-demo
cd slsa-demo
go mod init github.com/votreuser/slsa-demo
go mod tidy
git init
git add .
git commit -m "Initial commit"
gh repo create slsa-demo --public --source=. --remote=origin --push
rm -rf .git
git remote add origin https://github.com/votreuser/slsa-demo.git
git branch -M main
git push -u origin main

Ce script initialise un module Go vide, le commit et le pousse vers un nouveau repo GitHub public via gh CLI (installez-le avec brew install gh ou équivalent). Remplacez votreuser par votre username. Cela crée une base non-forkable, exigence SLSA niveau 1. Évitez les forks pour prévenir les attaques upstream.

Étape 1 : Ajouter le code source principal

Créez maintenant un programme Go simple 'hello world' qui servira d'artefact à build. Ce fichier main.go sera buildé de manière reproductible.

Créer le programme hello world

main.go

package main

import (
	"fmt"
	"os"
)

func main() {
	if len(os.Args) > 1 {
		fmt.Printf("Hello, %s! SLSA Level 1 build.\n", os.Args[1])
	} else {
		fmt.Println("Hello, World! SLSA Level 1 build.")
	}
}

Ce code Go compile en binaire exécutable. Il accepte un argument pour personnalisation (testable avec ./demo hello). Simple et déterministe : pas de timestamps ou aléas, clé pour SLSA reproductibilité. Committez et pushez : git add main.go; git commit -m 'Add main.go'; git push.

Étape 2 : Configurer le workflow SLSA Level 1

SLSA niveau 1 assure un build tamper-evident via GitHub Actions verrouillé. Utilisez l'action officielle slsa-framework/slsa-github-actions pour générer automatiquement la provenance (attestation JSON cryptée).

Workflow build et release SLSA 1

.github/workflows/slsa-level1.yml

name: SLSA Level 1 Build and Release

on:
  push:
    tags:
      - 'v*'

permissions:
  contents: read
  id-token: write

jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
      provenance_artifact: ${{ steps.provenance.outputs.provenance_artifact }}
    container:
      image: golang:1.21
    steps:
      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
        with:
          fetch-depth: 0
      - name: Build
        run: go build -o demo ./
      - uses: slsa-framework/slsa-github-generator/slsa-build@v1
        with:
          build-target: ./demo
          provenance-name: "slsa-demo"

  release:
    needs: build
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - uses: actions/download-artifact@4
        with:
          name: slsa-provenance
          path: provenance
      - uses: actions/create-release@0cb9b9b65be46c690df5f06b0e62e6e2a2de8b1f # v1.1.4
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          tag_name: ${{ github.ref }}
          release_name: Release ${{ github.ref }}
          draft: false
          prerelease: false
      - uses: actions/upload-release-asset@0bc79d5661a4a4ec3a5e6f4d8d5e1f1a2f2f0d2e # v1.0.3
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ steps.create_release.outputs.upload_url }}
          asset_path: ./demo
          asset_name: demo
          asset_content_type: application/octet-stream
      - uses: actions/upload-release-asset@0bc79d5661a4a4ec3a5e6f4d8d5e1f1a2f2f0d2e # v1.0.3
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ steps.create_release.outputs.upload_url }}
          asset_path: ./provenance/${{ needs.build.outputs.provenance_artifact }}
          asset_name: demo.provenance.attest
          asset_content_type: application/vnd.in-toto+json+attestation

Ce workflow se déclenche sur tags v*, build le binaire Go en container isolé, génère une attestation SLSA via slsa-build, et release l'artefact + provenance sur GitHub. Permissions minimales (id-token: write pour OIDC). Niveau 1 validé : non-forkable, source logged, build in-container. Poussez pour tester.

Étape 3 : Tester le workflow

Créez un tag et pushez : git tag v1.0.0; git push origin v1.0.0. Allez sur Actions > ce workflow. Succès ? Téléchargez release, vérifiez le binaire et l'attestation demo.provenance.attest.

Script de vérification locale SLSA

verify.sh

#!/bin/bash

# Téléchargez depuis GitHub release
curl -L -o demo https://github.com/votreuser/slsa-demo/releases/download/v1.0.0/demo
curl -L -o demo.provenance.attest https://github.com/votreuser/slsa-demo/releases/download/v1.0.0/demo.provenance.attest

# Vérifiez exécution
chmod +x demo
./demo Learni

# Installez slsa-verifier (go install sigs.dev/slsa/verifier/cmd/slsa-verifier@v2024...)
go install sigs.dev/slsa/verifier/cmd/slsa-verifier@v20240311

# Vérifiez SLSA niveau 1
slsa-verifier demo.provenance.attest \
  --source-github-repo votreuser/slsa-demo \
  --source-tag v1.0.0 \
  --source-digest sha256:$(sha256sum demo | cut -d' ' -f1)

rm demo demo.provenance.attest

Ce script télécharge l'artefact et provenance, exécute le binaire, puis utilise slsa-verifier pour valider la chaîne : repo source, tag, digest. Remplacez votreuser. Si 'VERIFIED', SLSA niveau 1 OK. Installez Go pour slsa-verifier. Piège : mauvais digest échoue.

Étape 4 : Passer à SLSA niveau 2

Niveau 2 ajoute scripted build et dependabot. Ajoutez un fichier pour verrouiller les actions.

Verrouillage actions pour SLSA 2

.github/workflows/slsa-level2.yml

name: SLSA Level 2 Enhanced

on:
  push:
    tags:
      - 'v*'

permissions:
  contents: read
  id-token: write

jobs:
  build:
    runs-on: ubuntu-latest
    container:
      image: golang:1.21@sha256:abcd123... # Pin image
    steps:
      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # pin v4.1.7
      - uses: slsa-framework/slsa-github-generator/slsa-build@v1.8.0 # pin
        with:
          build-target: ./demo
          provenance-name: "slsa-demo-level2"

  release:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - id: provenance
        uses: actions/download-artifact@v4
        with:
          path: ./
          pattern: slsa-provenance
      - uses: actions/create-release@v1
        with:
          tag_name: ${{ github.ref }}
          release_name: Level 2 ${{ github.ref }}
      # ... (similaire à précédent, avec pins)

Version upgradée avec pins SHA sur actions/images (.github/dependabot.yml pour auto-update). Ajoute scripted steps, prérequis SLSA 2. Copiez-collez après level1, taggez v2.0.0. Évite supply chain attacks via verrouillage. Vérifiez comme avant.

Dependabot pour mises à jour sécurisées

.github/dependabot.yml

version: 2
updates:
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "weekly"
    open-pull-requests-limit: 10
    rebase-strategy: auto
    groups:
      slsa-actions:
        patterns:
          - "slsa-framework/*"
        update-types:
          - "semver:major"
          - "semver:minor"
          - "semver:patch"
          - "version-update:semver:major"
          - "version-update:semver:minor"
          - "version-update:semver:patch"
    security-updates-only: false

Active Dependabot pour updater actions SLSA automatiquement via PR. Groupe SLSA pour priorisation. SLSA 2 exige updates contrôlées. Committez et activez dans repo Settings > Dependabot.

Bonnes pratiques

Toujours pin actions/images par SHA, pas tag (vulnérable aux hijacks).
Utilisez OIDC (id-token: write) au lieu de secrets GITHUB_TOKEN pour cosign/rekord.
Activez branch protection : require PR reviews, no direct push to main/tags.
Testez régulièrement avec slsa-verifier en CI.
Migrez vers niveau 3+ pour full hermetic builds (pas de network en build).

Erreurs courantes à éviter

Oublier fetch-depth: 0 : casse la vérif git history.
Pousser sur fork : SLSA exige repo propriétaire non-forkable.
Pas de container : build host-contaminated, fail niveau 1.
Ignorer provenance : téléchargez toujours l'attestation avec l'artefact.

Pour aller plus loin

Docs officielles : SLSA Framework
SLSA GitHub Generator : GitHub Repo
Vérifier niveaux : SLSA Verifier
Formations avancées DevSecOps : Découvrez nos formations Learni
Prochain : SLSA pour Docker/K8s avec Cosign.

Comment implémenter SLSA framework en 2026