Comment utiliser Gitleaks pour Git en 2026 (Avancé)

Introduction

En 2026, les fuites de secrets dans les dépôts Git représentent 85% des breaches de sécurité selon les rapports OWASP, causant des pertes estimées à des millions par incident. Gitleaks, outil open-source écrit en Go, scanne l'historique Git à la recherche de patterns sensibles comme les clés AWS, tokens JWT ou mots de passe SQL. Contrairement à des outils comme TruffleHog qui se focalisent sur l'entropie, Gitleaks excelle par sa vitesse (millions de commits en secondes) et sa configurabilité via regex custom. Ce tutoriel avancé vous guide de l'installation à l'intégration CI/CD, en passant par des règles personnalisées et baselines pour la remédiation. À la fin, vous automatiserez la détection dans vos pipelines, rendant vos repos impénétrables aux audits de conformité comme SOC2 ou GDPR. Idéal pour les équipes DevSecOps gérant des monorepos complexes.

Prérequis

Go 1.22+ installé (pour compilation native)
Git 2.45+ avec un dépôt de test contenant des secrets simulés
Accès à un repo GitHub pour CI/CD
Connaissances avancées en regex et YAML/TOML
Terminal Unix-like (WSL sur Windows)

Installation de Gitleaks

install.sh

go install github.com/gitleaks/gitleaks/v8@latest

gitleaks version

# Vérification : sortie attendue v8.18.4 ou supérieure
echo $?

# Option binaire statique pour CI/CD
CGO_ENABLED=0 go install -ldflags='-s -w' github.com/gitleaks/gitleaks/v8@latest

Ce script installe Gitleaks via Go modules, vérifie la version et compile une binaire statique optimisée pour les environnements CI sans dépendances Go. Évitez les proxies Go lents en utilisant directement @latest; la binaire statique réduit la taille de 70% en production.

Premier scan basique

Avant les configs avancées, testez Gitleaks sur un repo avec secrets factices. Créez un dépôt test : git init test-repo && cd test-repo && echo 'AWS_KEY=AKIAIOSFODNN7EXAMPLE' > secret.txt && git add . && git commit -m "add secret".

Scan initial d'un dépôt

scan-initial.sh

cd test-repo
gitleaks detect --source . --verbose --report-format json --report-path leaks.json

cat leaks.json

git log --oneline | head -5

Ce scan cible le répertoire courant, génère un rapport JSON détaillé avec empreintes hexadécimales pour remédiation précise. L'option --verbose affiche les règles matchées; utilisez --no-git pour scans non-Git comme S3 buckets.

Configuration TOML custom

.gitleaks.toml

title = "Config custom entreprise 2026"

[[rules]]
  id = "aws-access-key"
  description = "AWS Access Key ID"
  regex = '''AKIA[0-9A-Z]{16}'''
  entropy = 3.5
  keywords = [
    "aws_access_key",
    "aws_access_key_id"
  ]

[[rules]]
  id = "jwt-token-custom"
  description = "JWT Token entreprise"
  regex = '''eyJ[^\"]{100,}'''
  allowlist = [
    "public-jwt-example"
  ]

[baseline]
  path = ".gitleaks-baseline.toml"

[remediation]
  commit = true

Cette config TOML ajoute une règle AWS standard et une custom pour JWT avec allowlist pour faux positifs. La section baseline ignore les fuites historiques; remediation.commit=true automatise les squashes de secrets via gitleaks protect. Priorisez entropy pour réduire les faux positifs de 40%.

Scan avec configuration custom

Astuce : Placez .gitleaks.toml à la racine du repo. Pour monorepos, utilisez --config-path.

Scan avancé avec baseline

scan-custom.sh

# Générer baseline initiale
gitleaks detect --baseline .gitleaks-baseline.toml --source .

# Scan avec baseline (ignore fuites existantes)
gitleaks detect --baseline .gitleaks-baseline.toml --source . --exit-code 1 --report-path advanced-leaks.sarif

# Protection pré-push
exit 1  # Simule échec CI

La baseline capture l'état initial des fuites, permettant des scans incrémentaux sans alerter sur l'historique. --exit-code 1 force l'échec en CI; SARIF intègre avec GitHub CodeQL. Mettez à jour la baseline après remédiation avec gitleaks detect --update.

Hook pré-commit avec Husky

pre-commit.sh

#!/bin/sh
# .husky/pre-commit
gitleaks protect --source . --verbose

# Ou via pre-commit framework
# pip install pre-commit
# echo -e '[hooks]\n  - id: gitleaks\n    entry: gitleaks protect --staged' > .pre-commit-config.yaml
# pre-commit install

exit 0

Ce hook bloque les commits avec secrets en analysant le staging area uniquement (--staged). Intégrez avec Husky pour Node.js ou pre-commit pour multi-langages; ajoutez --redact-log pour masquer secrets dans les logs Git.

Intégration GitHub Actions

Pour CI/CD, embeddez Gitleaks dans workflows GitHub pour scans PR automatisés.

Workflow GitHub Actions

.github/workflows/gitleaks.yml

name: Gitleaks Scan

on: [push, pull_request]

jobs:
  gitleaks:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Install Gitleaks
        run: |
          curl -sSfL https://github.com/gitleaks/gitleaks/releases/download/v8.18.4/gitleaks_8.18.4_linux_x64.tar.gz | tar -xzf - gitleaks
          sudo mv gitleaks /usr/local/bin/
          gitleaks version
      - name: Scan
        uses: gitleaks/gitleaks-action@v2
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          config-path: .gitleaks.toml
          baseline-path: .gitleaks-baseline.toml
      - name: Upload SARIF
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: gitleaks.sarif

Ce workflow scanne à chaque push/PR, utilise une release statique pour fiabilité, et upload SARIF pour visualisation GitHub Security tab. fetch-depth: 0 assure historique complet; token auto pour private repos.

Bonnes pratiques

Règles custom prioritaires : Ajoutez toujours keywords pour contextualiser regex et réduire faux positifs de 60%.
Baselines en prod : Générez-les post-audit initial, versionnez-les en .gitleaks-baseline.private.toml (gitignore).
Intégration multi-CI : Utilisez Docker image ghcr.io/gitleaks/gitleaks:latest pour GitLab/Jenkins.
Redaction logs : Activez --redact pour masquer secrets dans rapports/Slack notifications.
Monitoring : Pipez JSON vers ELK pour dashboards fuites par repo/équipe.

Erreurs courantes à éviter

Oubli historique Git : Sans fetch-depth: 0 en CI, seuls les derniers commits sont scannés, manquant 90% des fuites.
Regex trop larges : Sans entropy ou keywords, faux positifs bloquent devs (ex: UUIDs comme API keys).
Pas de baseline : Scans initiaux échouent massivement sur legacy code; générez-la systématiquement.
Permissions CI : Token sans security-events:write empêche SARIF upload et annotations PR.

Pour aller plus loin

Docs officielles : Gitleaks GitHub
Règles communautaires : awesome-gitleaks
Alternative avancée : Intégrez avec GitGuardian pour S3 scans.
Formations : Découvrez nos formations DevSecOps Learni pour maîtriser Trivy + Gitleaks en pipelines end-to-end.

Comment détecter les secrets Git avec Gitleaks en 2026