audit-sécurité-infrastructure-terraform

Audit de l'infrastructure Terraform pour la sécurité

Quand l'utiliser

• Lors de l'intégration d'un scan de sécurité dans les pipelines CI/CD pour les déploiements Terraform
• Lors de la révision des plans et modules Terraform pour les bonnes pratiques de sécurité avant application
• Lors de la mise en place de garde-fous de type "policy-as-code" pour le provisionnement de l'infrastructure cloud
• Lors de l'audit des fichiers d'état Terraform existants pour identifier les erreurs de configuration déployées
• Lors de l'application de normes de sécurité organisationnelles sur plusieurs projets Terraform

Ne pas utiliser pour la surveillance de sécurité en runtime (utilisez des outils CSPM), pour les tests de sécurité applicative (utilisez des outils SAST/DAST), ou pour la détection de dérive de configuration cloud (utilisez AWS Config ou Azure Policy après déploiement).

Prérequis

• Checkov installé (pip install checkov)
• tfsec installé (brew install tfsec ou binaire depuis GitHub)
• Terrascan installé (brew install terrascan)
• Terraform v1.0+ pour la génération de plan
• OPA (Open Policy Agent) pour l'application de politiques personnalisées
• Dépôt Git avec du code Terraform à auditer

Workflow

Étape 1 : Scanner le code Terraform avec Checkov

Exécutez Checkov pour un scan complet de sécurité IaC avec des politiques intégrées et personnalisées.

# Scanner un répertoire Terraform
checkov -d ./terraform/ --framework terraform

# Scanner avec des catégories de vérification spécifiques
checkov -d ./terraform/ --check CKV_AWS_18,CKV_AWS_19,CKV_AWS_20,CKV_AWS_21

# Scanner et produire des résultats en JSON
checkov -d ./terraform/ --output json > checkov-results.json

# Scanner un fichier de plan Terraform pour une analyse plus précise
terraform init && terraform plan -out=tfplan
terraform show -json tfplan > tfplan.json
checkov -f tfplan.json --framework terraform_plan

# Ignorer des vérifications spécifiques avec justification
checkov -d ./terraform/ --skip-check CKV_AWS_145 \
  --bc-api-key $BRIDGECREW_API_KEY

# Scanner les modules Terraform
checkov -d ./modules/ --framework terraform --compact

# Lister toutes les vérifications disponibles
checkov --list --framework terraform | grep CKV_AWS

Étape 2 : Scanner avec tfsec pour les problèmes spécifiques à Terraform

Utilisez tfsec pour une analyse de sécurité native Terraform avec des conseils de correction détaillés.

# Scanner un répertoire Terraform
tfsec ./terraform/

# Scanner avec un seuil de sévérité minimum
tfsec ./terraform/ --minimum-severity HIGH

# Sortie en JSON pour le traitement CI/CD
tfsec ./terraform/ --format json > tfsec-results.json

# Scanner avec des vérifications personnalisées
tfsec ./terraform/ --custom-check-dir ./custom-checks/

# Exclure des règles spécifiques
tfsec ./terraform/ --exclude-downloaded-modules \
  --exclude aws-s3-enable-bucket-logging

# Scanner et échouer sur une sévérité spécifique
tfsec ./terraform/ --minimum-severity CRITICAL --soft-fail

# Générer une sortie SARIF pour l'onglet Sécurité GitHub
tfsec ./terraform/ --format sarif > tfsec.sarif

Étape 3 : Exécuter Terrascan pour la conformité multi-cadres

Exécutez Terrascan pour la vérification de conformité par rapport aux benchmarks CIS, NIST et SOC 2.

# Scanner Terraform par rapport au benchmark CIS AWS
terrascan scan -t aws -i terraform -d ./terraform/ \
  --policy-type aws --verbose

# Scanner par rapport à des cadres de conformité spécifiques
terrascan scan -t aws -i terraform -d ./terraform/ \
  --policy-type aws \
  --categories "Compliance Validation"

# Sortie en JSON
terrascan scan -t aws -i terraform -d ./terraform/ \
  --output json > terrascan-results.json

# Scanner un plan Terraform
terrascan scan -t aws -i terraform \
  --iac-file tfplan.json \
  --iac-type tfplan

# Lister les politiques disponibles
terrascan scan --list-policies -t aws

Étape 4 : Créer des politiques OPA personnalisées pour les normes organisationnelles

Écrivez des politiques Rego pour les exigences de sécurité spécifiques à l'organisation.

# policy/aws_s3_encryption.rego
package terraform.aws.s3

denied[msg] {
    resource := input.resource.aws_s3_bucket[name]
    not resource.server_side_encryption_configuration
    msg := sprintf("Le bucket S3 '%s' doit avoir le chiffrement côté serveur activé", [name])
}

# policy/aws_iam_no_wildcards.rego
package terraform.aws.iam

denied[msg] {
    resource := input.resource.aws_iam_policy[name]
    statement := resource.policy.Statement[_]
    statement.Action == "*"
    statement.Effect == "Allow"
    msg := sprintf("La politique IAM '%s' ne doit pas utiliser d'actions génériques (*)", [name])
}

denied[msg] {
    resource := input.resource.aws_iam_policy[name]
    statement := resource.policy.Statement[_]
    statement.Resource == "*"
    statement.Effect == "Allow"
    contains(statement.Action[_], "*")
    msg := sprintf("La politique IAM '%s' a des actions trop permissives sur des ressources génériques", [name])
}

# policy/aws_no_public_ingress.rego
package terraform.aws.security_group

denied[msg] {
    resource := input.resource.aws_security_group_rule[name]
    resource.type == "ingress"
    resource.cidr_blocks[_] == "0.0.0.0/0"
    resource.from_port <= 22
    resource.to_port >= 22
    msg := sprintf("La règle de groupe de sécurité '%s' autorise SSH depuis 0.0.0.0/0", [name])
}

# Évaluer le plan Terraform par rapport aux politiques OPA
terraform show -json tfplan | opa eval \
  --data ./policy/ \
  --input /dev/stdin \
  "data.terraform.aws" \
  --format pretty

# Exécuter Conftest pour faciliter les tests des politiques OPA
conftest test tfplan.json --policy ./policy/ --output json

Étape 5 : Intégrer le scan de sécurité dans le pipeline CI/CD

Ajoutez le scan de sécurité IaC comme une étape obligatoire dans le CI/CD.

# GitHub Actions : Pipeline de sécurité Terraform
name: Scan de sécurité Terraform
on:
  pull_request:
    paths: ['terraform/**']

jobs:
  security-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Configuration Terraform
        uses: hashicorp/setup-terraform@v3

      - name: Init & Plan Terraform
        run: |
          cd terraform/
          terraform init
          terraform plan -out=tfplan
          terraform show -json tfplan > tfplan.json

      - name: Scan Checkov
        uses: bridgecrewio/checkov-action@master
        with:
          directory: terraform/
          framework: terraform
          output_format: sarif
          output_file_path: checkov.sarif
          soft_fail: false

      - name: Scan tfsec
        uses: aquasecurity/[email protected]
        with:
          working_directory: terraform/
          soft_fail: false

      - name: Télécharger SARIF
        uses: github/codeql-action/upload-sarif@v2
        with:
          sarif_file: checkov.sarif

      - name: Vérification des politiques OPA
        run: |
          conftest test terraform/tfplan.json \
            --policy ./policy/ \
            --output json

Étape 6 : Scanner l'état Terraform pour les erreurs de configuration déployées

Auditez l'état Terraform actuel pour identifier les problèmes de sécurité déjà déployés.

# Exporter l'état actuel au format JSON
terraform show -json > terraform-state.json

# Scanner l'état avec Checkov
checkov -f terraform-state.json --framework terraform_plan

# Interroger l'état pour des problèmes de sécurité spécifiques
terraform state list | while read resource; do
  terraform state show "$resource" 2>/dev/null | grep -i "public\|0.0.0.0\|encrypt.*false\|password"
done

# Trouver les ressources sans les tags requis
terraform state list | grep aws_instance | while read resource; do
  tags=$(terraform state show "$resource" | grep -A20 "tags")
  if ! echo "$tags" | grep -q "Environment"; then
    echo "TAG MANQUANT : $resource n'a pas le tag 'Environment'"
  fi
done

Concepts clés

Terme	Définition
Infrastructure as Code	Pratique de gestion de l'infrastructure cloud via des fichiers de configuration déclaratifs (Terraform, CloudFormation) plutôt que des opérations manuelles via la console
Policy as Code	Expression des politiques de sécurité et de conformité sous forme de code exécutable (Rego, Python) pouvant être évalué automatiquement par rapport aux définitions de l'infrastructure
Shift Left Security	Déplacement des contrôles de sécurité en amont dans le cycle de développement en scannant l'IaC avant le déploiement plutôt qu'après le provisionnement
Terraform Plan	Aperçu des modifications que Terraform va apporter, pouvant être exporté au format JSON pour un scan de sécurité avant d'appliquer les changements
Checkov	Outil d'analyse statique open source pour l'IaC prenant en charge Terraform, CloudFormation, Kubernetes et Docker avec plus de 1000 politiques intégrées
OPA/Rego	Open Policy Agent et son langage de politiques Rego pour définir des règles de sécurité personnalisées évaluées par rapport à des entrées de données structurées

Outils et systèmes

• Checkov : Scanner IaC complet avec plus de 1000 politiques pour Terraform, CloudFormation, Kubernetes, ARM et Dockerfile
• tfsec : Outil d'analyse statique spécifique à Terraform avec des conseils de correction détaillés et une sortie SARIF
• Terrascan : Scanner multi-IaC prenant en charge les cadres de conformité (CIS, NIST, SOC 2) avec policy-as-code
• OPA/Conftest : Moteur de politiques personnalisées pour définir des règles de sécurité spécifiques à l'organisation en utilisant le langage Rego
• Bridgecrew : Plateforme commerciale basée sur Checkov offrant la détection de dérive et la sécurité de la chaîne d'approvisionnement

Scénarios courants

Scénario : Ajout de garde-fous de sécurité à un pipeline CI/CD Terraform existant

Contexte : Une équipe DevOps déploie son infrastructure via Terraform dans GitHub Actions mais n'a pas de scan de sécurité. Des audits récents montrent plusieurs buckets S3 sans chiffrement et des groupes de sécurité autorisant SSH depuis Internet.

Approche :

1. Ajouter Checkov comme premier garde-fou de sécurité dans le workflow GitHub Actions
2. Exécuter checkov -d ./terraform/ pour établir la base de référence des résultats
3. Trier les résultats existants : corriger les problèmes CRITIQUES, créer des tickets pour les HAUTS, supprimer les risques acceptés
4. Ajouter tfsec comme scanner secondaire pour les vérifications spécifiques à Terraform
5. Écrire des politiques OPA personnalisées pour les normes organisationnelles (tags requis, conventions de nommage)
6. Configurer le pipeline pour bloquer les PR avec des résultats CRITIQUES ou HAUTS
7. Générer des rapports SARIF pour l'intégration dans l'onglet Sécurité GitHub

Pièges : L'ajout d'un scan de sécurité à un projet existant produira initialement des centaines de résultats. Implémentez progressivement en commençant par le blocage CRITIQUE uniquement, puis en passant à HAUT. Utilisez des commentaires de suppression en ligne (#checkov:skip=CKV_AWS_18:Bucket public pour site web statique) pour les exceptions intentionnelles avec justification documentée.

Format de sortie

Rapport d'audit de sécurité Terraform
========================================
Dépôt : acme-corp/infrastructure
Branche : main
Date du scan : 2026-02-23
Outils : Checkov 3.x, tfsec 1.x, politiques personnalisées OPA

RÉSULTATS DU SCAN :
  Vérifications Checkov réussies :    187
  Vérifications Checkov échouées :     34
  Vérifications tfsec réussies :      156
  Vérifications tfsec échouées :       28
  Politiques OPA personnalisées :       12 réussies, 3 échouées

RÉSULTATS CRITIQUES :
[TF-001] Bucket S3 sans chiffrement
  Fichier : modules/storage/main.tf:24
  Ressource : aws_s3_bucket.data_lake
  Vérification : CKV_AWS_19
  Correction : Ajouter le bloc server_side_encryption_configuration

[TF-002] Groupe de sécurité autorise SSH depuis 0.0.0.0/0
  Fichier : modules/network/security.tf:45
  Ressource : aws_security_group_rule.ssh_access
  Vérification : CKV_AWS_24
  Correction : Restreindre cidr_blocks au sous-réseau bastion

[TF-003] Politique IAM avec actions génériques
  Fichier : modules/iam/policies.tf:12
  Ressource : aws_iam_policy.developer_policy
  Vérification : CKV_AWS_1
  Correction : Limiter les actions aux services spécifiques requis

RÉSUMÉ PAR SÉVÉRITÉ :
  Critique :    6 résultats
  Haute :      14 résultats
  Moyenne :    28 résultats
  Basse :      18 résultats
  Info :       12 résultats