138% de CVE signalées en plus par jour en 2026 par rapport à l'an dernier.Nouveau : les Fixboxes toujours actives. Dépendances vulnérables, corrigées et vérifiées.

Sécurité CI/CD

Sécurité GitHub Actions : une checklist pour durcir vos workflows

Un workflow GitHub Actions exécute du code écrit par de nombreux auteurs avec le token de votre dépôt, vos secrets et un chemin vers la production. La plupart des contrôles qui le protègent sont intégrés à GitHub, mais par défaut ils sont désactivés, trop permissifs ou faciles à mal configurer. Cette checklist les passe en revue un par un : quoi configurer, pourquoi c'est important et l'incident qui montre ce qui arrive sans.

Mis à jour le

La checklist en un coup d'œil

Point Ce qu'il empêche
GITHUB_TOKEN au moindre privilège Une étape détournée qui pousse du code, publie des releases ou déclenche d'autres workflows
Épingler ou verrouiller les actions tierces Un tag déplacé qui exécute le code d'un attaquant dans votre job
Traiter pull_request_target et workflow_run comme privilégiés Les pwn requests : du code de fork exécuté avec vos secrets
Tenir les données d'événement à l'écart des scripts run L'injection de script via les titres, les noms de branche et les commentaires
OIDC au lieu de clés cloud stockées Des identifiants de longue durée qui fonctionnent encore des années après une fuite
Environnements avec relecteurs obligatoires N'importe quelle branche ou n'importe quel workflow lisant les secrets de production
Code owners sur .github/workflows Des modifications non relues de ce que le pipeline exécute
Politique d'actions autorisées Des actions inconnues ou non épinglées partout dans l'organisation
Pas de runners auto-hébergés sur les dépôts publics Des inconnus qui exécutent du code sur vos machines
Hygiène des caches et des artefacts Des caches empoisonnés et des tokens qui fuient via les uploads
Contrôle du trafic sortant sur les runners Des secrets volés envoyés vers le serveur d'un attaquant
Un enregistrement de chaque exécution Ne pas savoir quels builds ont exécuté une action ou un paquet compromis

Code des workflows

1. Donnez à GITHUB_TOKEN le moindre privilège

Chaque job reçoit un GITHUB_TOKEN, et n'importe quelle étape du job peut l'utiliser. Les dépôts et organisations créés avant février 2023 peuvent encore accorder par défaut la lecture et l'écriture sur toutes les permissions. Réglez la valeur par défaut sur la lecture seule sous Settings → Actions → General → Workflow permissions, puis accordez l'écriture job par job :

permissions:
  contents: read

jobs:
  release:
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - uses: actions/checkout@<full-commit-sha>

Tout ce que vous ne listez pas passe à none. Pour chaque permission et ce dont les tâches courantes ont besoin, voir permissions de GITHUB_TOKEN : le moindre privilège pour chaque workflow.

2. Épinglez les actions tierces sur un commit, ou verrouillez-les

Un tag comme @v4 est un pointeur que le propriétaire de l'action, ou quiconque lui vole ses accès, peut déplacer. Deux incidents montrent ce que cela signifie :

  • tj-actions/changed-files, mars 2025. Un attaquant a modifié des tags de version existants pour les faire pointer vers un commit malveillant (CVE-2025-30066). L'action était utilisée par plus de 23 000 dépôts, et la charge utile affichait les secrets de la mémoire du runner dans les logs du workflow, que n'importe qui peut lire sur un dépôt public.
  • aquasecurity/trivy-action, mars 2026. L'avis d'Aqua Security (CVE-2026-33634) indique que 76 des 77 tags de version de l'action ont été redirigés de force vers des commits malveillants. Le code injecté s'exécutait avant le vrai scan, lisait les secrets dans la mémoire du runner et les envoyait, chiffrés, vers l'infrastructure de l'attaquant.

Les workflows qui référençaient un SHA de commit complet ont continué d'exécuter le même code qu'avant. Gardez la version en commentaire :

steps:
  # Mutable: whoever controls the tag decides what runs
  - uses: tj-actions/changed-files@v45
  # Immutable: a full commit SHA, with the version as a comment
  - uses: tj-actions/changed-files@<full-commit-sha> # v46.0.1

Vérifiez que le SHA provient du dépôt de l'action elle-même, et non d'un fork. GitHub propose désormais mieux : les lockfiles de dépendances de workflow, disponibles pour tous depuis le 28 octobre 2026. L'extension CLI gh actions-lock écrit .github/workflows/actions.lock, qui enregistre le commit exact de chaque action utilisée par vos workflows, y compris les actions que ces actions appellent, et GitHub vérifie à l'exécution que chaque dépôt source est toujours celui que vous avez verrouillé. Les appels à des workflows réutilisables ne sont pas couverts : épinglez-les par SHA. Les administrateurs peuvent imposer un lockfile par politique. Ni l'épinglage ni un lockfile ne rendent une action sûre : relisez ce que vous verrouillez.

Les actions épinglées ne se mettent pas à jour toutes seules. Laissez Dependabot proposer les mises à jour, avec un délai d'attente pour qu'une nouvelle release ait quelques jours pour être repérée avant de vous atteindre :

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "weekly"
    cooldown:
      default-days: 7

3. Traitez pull_request_target et workflow_run comme privilégiés

Un workflow pull_request déclenché depuis un fork reçoit un token en lecture seule et aucun secret. Un workflow pull_request_target s'exécute dans le contexte du dépôt de base, avec ses secrets et un token qui peut écrire, même quand la pull request vient d'un fork. Ce n'est sûr que tant que le workflow n'exécute jamais de code issu de la pull request. Extrayez la tête de la pull request et buildez-la, et chaque script d'installation et chaque test de cette pull request s'exécute avec vos secrets. GitHub Security Lab les appelle des pwn requests.

  • Utilisez pull_request pour tout ce qui builde ou teste du code contribué.
  • Si une étape privilégiée doit suivre, comme commenter la pull request, séparez-la : un workflow pull_request non privilégié charge ses résultats comme artefact, et un workflow workflow_run agit dessus. Traitez ces artefacts comme une entrée non fiable, jamais comme du code à exécuter.
  • Dans les dépôts publics sans politique d'événements, GitHub bloque pull_request_target par défaut à partir du 2 décembre 2026. Si vous le réautorisez, n'autorisez que les workflows qui en ont besoin.

La compromission de TanStack en mai 2026 a commencé ainsi : un workflow pull_request_target a exécuté du code de fork, qui a empoisonné le cache qu'un workflow de release a restauré plus tard, et un token OIDC lu dans la mémoire du runner a servi à publier 84 versions malveillantes de 42 paquets.

4. Tenez les données d'événement à l'écart des scripts run

Les expressions sont développées avant l'exécution du shell : un titre de pull request, un nom de branche, le corps d'une issue ou un message de commit placé dans run devient donc une partie du script. Quiconque peut ouvrir une pull request ou une issue peut alors exécuter des commandes dans votre job. Passez la valeur par une variable d'environnement, pour que le shell la traite comme une donnée :

# Vulnerable: the title is pasted into the script before the shell runs
- run: echo "Checking ${{ github.event.pull_request.title }}"

# Safe: the shell reads the title as data
- env:
    PR_TITLE: ${{ github.event.pull_request.title }}
  run: echo "Checking $PR_TITLE"

Il en va de même pour actions/github-script et pour les valeurs écrites dans GITHUB_ENV. Les agents IA dans les workflows ajoutent une nouvelle forme du même problème : le texte d'une issue peut piloter l'agent au lieu du shell. Voir l'injection de prompt.

Secrets et déploiements

5. Utilisez OIDC plutôt que des clés cloud de longue durée

Une clé d'accès cloud stockée comme secret fonctionne jusqu'à ce que quelqu'un la renouvelle, ce qui, après une fuite, arrive souvent trop tard. Avec OpenID Connect, le job demande à GitHub un token de courte durée et l'échange auprès d'AWS, d'Azure ou de Google Cloud, dont la politique de confiance décide quel dépôt, quelle branche ou quel environnement peut assumer le rôle :

jobs:
  deploy:
    runs-on: ubuntu-latest
    environment: production
    permissions:
      contents: read
      id-token: write
    steps:
      - uses: aws-actions/configure-aws-credentials@<full-commit-sha>
        with:
          role-to-assume: arn:aws:iam::123456789012:role/deploy
          aws-region: us-east-1

Un token de courte durée peut toujours être volé dans un job en cours d'exécution, comme TanStack l'a montré, mais il vaut bien moins qu'une clé qui n'expire jamais. Transmettez les secrets que vous conservez à l'étape qui en a besoin plutôt qu'à tout le job, pour que les autres actions du job ne puissent pas les lire. Comment les secrets fuient et les autres contrôles sont détaillés dans secrets GitHub Actions : comment ils fuient et comment les verrouiller.

6. Placez la production derrière des environnements avec relecteurs obligatoires

Un environnement détient ses propres secrets, et un job qui le nomme ne peut pas les lire tant qu'un relecteur obligatoire n'a pas approuvé l'exécution. Les règles de branches de déploiement limitent les branches qui peuvent l'utiliser. Un workflow sur une branche de fonctionnalité, ou déclenché par une pull request, n'a alors aucun accès aux identifiants de production.

Gouvernance

7. Exigez une revue par un code owner pour les fichiers de workflow

Un fichier de workflow décide de ce qui s'exécute avec vos secrets : une modification mérite donc la même revue qu'un changement d'accès à la production. Ajoutez le dossier à CODEOWNERS et exigez une revue par un code owner dans un ruleset de branche :

/.github/workflows/ @example-org/platform-security
/.github/actions/ @example-org/platform-security

8. Restreignez les actions autorisées

Au niveau de l'entreprise, de l'organisation ou du dépôt, la politique d'actions autorisées peut limiter les actions à celles de GitHub, de créateurs vérifiés ou d'une liste que vous maintenez. Depuis août 2025, elle peut aussi imposer l'épinglage par SHA, de sorte qu'un workflow qui utilise une action non épinglée échoue, et bloquer une action ou une version précise avec une entrée !, ce qui aide le jour où une action que vous utilisez est signalée comme compromise.

Runners, caches et artefacts

9. Tenez les runners auto-hébergés à l'écart des dépôts publics

La référence d'usage sécurisé de GitHub indique que les runners auto-hébergés ne devraient presque jamais être utilisés pour des dépôts publics, car n'importe qui peut ouvrir une pull request et exécuter du code dessus. Sur les dépôts privés, utilisez des runners qui repartent de zéro pour chaque job : un runner de longue durée garde tout ce qu'un job laisse derrière lui pour le suivant, y compris une porte dérobée. Le ver npm Shai-Hulud enregistrait les machines infectées comme runners auto-hébergés précisément pour cette raison. Voir runners managés ou auto-hébergés.

10. Protégez les caches contre l'empoisonnement

Les caches sont limités par branche, et les caches enregistrés sur la branche par défaut peuvent être restaurés par toutes les autres branches. Du code qui s'exécute dans n'importe quel workflow de la branche par défaut peut donc écrire des entrées de cache qu'un workflow de release restaurera plus tard, sans avoir besoin d'un token en écriture. Tenez le code non fiable à l'écart des workflows de la branche par défaut, évitez de restaurer des caches dans les jobs de release et de publication, et reconstruisez-y plutôt à partir d'un lockfile. Voir comment fonctionne le cache GitHub Actions.

11. Traitez les artefacts comme non fiables

actions/checkout conserve le token sur le disque pour les commandes git suivantes, sauf si vous le désactivez. Charger l'espace de travail comme artefact a déjà fait fuiter ce token par le passé. Réglez persist-credentials: false sur les checkouts qui ne poussent rien, ne chargez que les chemins dont vous avez besoin, et n'exécutez jamais un artefact issu d'une pull request dans un workflow privilégié :

- uses: actions/checkout@<full-commit-sha>
  with:
    persist-credentials: false

Réseau et enregistrements

12. Contrôlez où les jobs peuvent se connecter

Les runners hébergés par GitHub ne restreignent pas le trafic sortant : le code d'un job peut donc envoyer ce qu'il lit n'importe où. La plupart des jobs n'ont besoin que d'une courte liste de destinations : registres de paquets, registres de conteneurs, hébergeurs de sources et quelques API. Autorisez-les et bloquez le reste, et un secret volé n'a nulle part où aller, même lors d'une attaque que personne n'a encore vue. Une politique de trafic sortant n'empêche pas les secrets affichés dans les logs, comme dans le cas tj-actions : c'est pourquoi elle s'ajoute à l'épinglage, sans le remplacer. Voir comment une politique de trafic sortant arrête l'exfiltration depuis GitHub Actions.

13. Enregistrez les actions et les paquets utilisés par chaque exécution

Quand la prochaine action ou le prochain paquet compromis est annoncé, la première question est de savoir lesquelles de vos exécutions l'ont utilisé. Un fichier de workflow dit ce qu'une exécution était censée utiliser. Un tag, une plage de versions ou un cache hit peuvent changer la réponse, et l'enregistrement qui tranche est celui pris pendant l'exécution du job : le commit de chaque action, chaque paquet récupéré ou restauré depuis un cache, et les connexions établies par le job. Voir les SBOM dans GitHub Actions.

Outils gratuits qui auditent vos workflows

La plupart des points de workflow ci-dessus peuvent être vérifiés automatiquement. Ces outils lisent les fichiers de workflow ; ils n'observent pas un job pendant son exécution.

Outil Ce qu'il vérifie
zizmor Analyse statique de la configuration GitHub Actions, Dependabot et pre-commit : injection de template, déclencheurs dangereux, permissions excessives, actions non épinglées, commits usurpés, empoisonnement de cache et identifiants laissés par checkout
actionlint Un linter pour la syntaxe et les expressions des workflows, qui signale aussi les valeurs non fiables utilisées dans des scripts inline et exécute shellcheck sur les étapes run
OpenSSF Scorecard Des contrôles de dépôt, dont Dangerous-Workflow (checkouts non fiables et injection de script), Token-Permissions et Pinned-Dependencies
poutine Le scanner open source de BoostSecurity pour les pipelines de build, qui couvre GitHub Actions, GitLab, Azure DevOps et Tekton et peut scanner tous les dépôts d'une organisation
CodeQL Le code scanning de GitHub, qui analyse les workflows à la recherche d'injections et de schémas de pwn request depuis 2025

Exécutez l'un d'eux dans les pull requests qui touchent .github/. Pour savoir comment ils s'articulent avec les contrôles au niveau du runner et les outils de posture, voir le comparatif des outils de sécurité CI/CD et la sécurité CI/CD. Pour une checklist qui couvre tout le pipeline plutôt que les réglages de GitHub Actions, voir la checklist de sécurité des pipelines CI/CD.

Comment CRACI aide

CRACI remplace le runner, pas GitHub Actions : vous changez runs-on en craci, et les workflows, les secrets, les permissions du token et l'historique des exécutions restent dans GitHub. Il couvre les derniers points de cette liste, ceux qui se jouent pendant l'exécution d'un job :

  • Contrôle du trafic sortant. Une politique de trafic sortant décide quelles sources de paquets, quels registres et quels hôtes un job peut atteindre. Elle est validée avant le démarrage du job, appliquée au niveau du runner et bloque tout en cas d'échec, et une connexion bloquée déclenche une alerte.
  • Un enregistrement de chaque exécution. La SBOM du job liste les GitHub Actions qu'il a exécutées comme composants pkg:github épinglés sur le commit utilisé, ainsi que chaque paquet qu'il a récupéré, y compris les paquets restaurés depuis un cache, avec une trace de ses connexions réseau. Quand les tags d'une action sont déplacés, vous voyez quel commit chaque exécution a réellement exécuté.
  • Gates de politique. Un build qui intègre un paquet présentant une vulnérabilité connue, y compris une CVE précise, peut être arrêté.
  • Isolation. Chaque job s'exécute dans sa propre machine virtuelle : rien ne passe au suivant.

CRACI n'audite pas vos fichiers de workflow, ne scanne pas le code source et ne recherche pas les secrets : gardez pour cela un linter de workflows comme zizmor, le secret scanning de GitHub et votre outil SAST. Il exécute les jobs GitHub Actions sous Linux, et les autres systèmes CI figurent sur la roadmap.

Sécurité GitHub Actions : questions fréquentes

Comment sécuriser GitHub Actions ?

Réglez GITHUB_TOKEN en lecture seule et accordez l'écriture job par job, épinglez ou verrouillez les actions tierces, évitez d'exécuter le code des pull requests dans les workflows pull_request_target, passez les données d'événement aux scripts via des variables d'environnement, utilisez OIDC au lieu de clés cloud stockées, placez les secrets de production derrière des environnements, exigez la revue des fichiers de workflow et contrôlez ce à quoi les jobs peuvent se connecter.

Faut-il épingler les GitHub Actions sur un SHA de commit ?

Oui, pour les actions tierces. Un tag peut être déplacé vers un autre code, comme ce fut le cas pour tj-actions/changed-files en 2025 et trivy-action en 2026, alors qu'un SHA de commit complet ne le peut pas. Les lockfiles de workflow de GitHub vont plus loin et verrouillent aussi les actions que vos actions appellent.

pull_request_target est-il dangereux ?

Il n'est sûr que si le workflow n'exécute jamais de code issu de la pull request. Il s'exécute avec les secrets du dépôt de base et un token en écriture, même pour les forks : builder du code de fork dans ce workflow remet donc les deux à l'auteur de la pull request. GitHub le bloque par défaut dans les dépôts publics sans politique d'événements à partir du 2 décembre 2026.

Qu'est-ce qu'une pwn request ?

Le nom donné par GitHub Security Lab à un workflow privilégié, généralement déclenché par pull_request_target, qui extrait et exécute du code non fiable issu d'une pull request, donnant à son auteur accès aux secrets et au token du workflow.

Les lockfiles de workflow valent-ils mieux que l'épinglage par SHA ?

Ils sont plus robustes. Un lockfile enregistre le commit de chaque action utilisée par un workflow, y compris les actions transitives, et GitHub vérifie l'identité du dépôt source à l'exécution. Les appels à des workflows réutilisables ne sont pas couverts : épinglez-les par SHA.

Quels outils gratuits vérifient la sécurité des workflows GitHub Actions ?

zizmor, actionlint, OpenSSF Scorecard et poutine sont gratuits, et CodeQL peut analyser les workflows dans le cadre du code scanning de GitHub. Ils lisent les fichiers de workflow ; ils ne contrôlent pas ce que fait un job pendant son exécution.

Voyez ce que l'un de vos workflows a réellement exécuté

Exécutez un job GitHub Actions sur CRACI et obtenez le commit de chaque action, chaque paquet récupéré et une politique de trafic sortant qui bloque tout en cas d'échec.

Réserver une démo