Sécurité de l'Infrastructure as Code | Decripte Security

L'Infrastructure as Code apporte des bénéfices de versioning et d'automatisation mais introduit des risques si les misconfigurations sont propagées automatiquement. La sécurité doit être shift-left pour l'IaC.

Vulnérabilités courantes dans l'IaC

• Hardcoded secrets : Identifiants dans le code versionné
• Règles trop permissives : Security groups 0.0.0.0/0
• Ressources non chiffrées : Buckets S3, RDS sans chiffrement
• Accès public : Ressources exposées inutilement
• Logging manquant : CloudTrail, flow logs désactivés
• Authentification faible : MFA non imposé

Outils de scanning

Terraform - tfsec, Checkov, Terrascan

      # Exemple de vulnérabilité - bucket S3 public
      resource "aws_s3_bucket" "bad_bucket" {
      bucket = "my-public-bucket"
      acl    = "public-read"  # [ERREUR] VULNÉRABLE
      }
      # Correction
      resource "aws_s3_bucket" "good_bucket" {
      bucket = "my-private-bucket"
      acl    = "private"  # [OK] Sécurisé
      server_side_encryption_configuration {
      rule {
      apply_server_side_encryption_by_default {
      sse_algorithm = "AES256"
      }
      }
      }
      versioning {
      enabled = true
      }
      }
      resource "aws_s3_bucket_public_access_block" "good_bucket" {
      bucket = aws_s3_bucket.good_bucket.id
      block_public_acls       = true
      block_public_policy     = true
      ignore_public_acls      = true
      restrict_public_buckets = true
      }
      

tfsec - Scanning Terraform

      # Install
      brew install tfsec
      # Scan Terraform files
      tfsec .
      # Sortie spécifique
      tfsec --format json --out results.json .
      # CI/CD integration
      tfsec --soft-fail . || exit 1
      

Checkov - Scanner IaC Multi-Cloud

      # Install
      pip install checkov
      # Scan Terraform
      checkov -d ./terraform
      # Scan CloudFormation
      checkov -f template.yaml
      # Scan Kubernetes manifests
      checkov -d ./k8s
      # Skip specific checks
      checkov -d . --skip-check CKV_AWS_20
      # Custom policies
      checkov -d . --external-checks-dir ./custom-policies
      

Policy as Code

Open Policy Agent (OPA)

OPA permet d'écrire des policies dans le langage Rego pour imposer la conformité :

      # deny_public_s3.rego
      package terraform.aws.s3
      deny[msg] {
      resource := input.resource_changes[_]
      resource.type == "aws_s3_bucket"
      resource.change.after.acl == "public-read"
      msg := sprintf("S3 bucket %s cannot be public", [resource.address])
      }
      deny[msg] {
      resource := input.resource_changes[_]
      resource.type == "aws_s3_bucket"
      not resource.change.after.server_side_encryption_configuration
      msg := sprintf("S3 bucket %s must have encryption enabled", [resource.address])
      }
      

Sentinel (HashiCorp)

Framework de policies intégré à Terraform Cloud/Enterprise :

      # enforce-mandatory-tags.sentinel
      import "tfplan/v2" as tfplan
      mandatory_tags = ["Environment", "Owner", "Project"]
      all_resources = filter tfplan.resource_changes as _, rc {
      rc.mode is "managed"
      }
      deny_resources_without_tags = rule {
      all all_resources as _, resource {
      all mandatory_tags as tag {
      resource.change.after.tags contains tag
      }
      }
      }
      

Secrets Management dans l'IaC

Terraform - Utilisation d'AWS Secrets Manager

      # Créer un secret dans Secrets Manager
      resource "aws_secretsmanager_secret" "db_password" {
      name = "production/db/password"
      recovery_window_in_days = 30
      }
      resource "aws_secretsmanager_secret_version" "db_password" {
      secret_id     = aws_secretsmanager_secret.db_password.id
      secret_string = random_password.db_password.result
      }
      # Référencer le secret (n'expose pas la valeur)
      data "aws_secretsmanager_secret_version" "db_password" {
      secret_id = aws_secretsmanager_secret.db_password.id
      }
      # Utiliser dans RDS (référence, pas de valeur hardcoded)
      resource "aws_db_instance" "main" {
      # ... autres configs
      password = data.aws_secretsmanager_secret_version.db_password.secret_string
      }
      

git-secrets - Empêcher les commits de secrets

      # Install git-secrets
      brew install git-secrets
      # Setup hooks pour le dépôt
      git secrets --install
      git secrets --register-aws
      # Scan de l'historique des commits
      git secrets --scan-history
      # Empêcher les commits contenant des secrets
      # Automatique via pre-commit hook
      

Sécurité du State File

• Remote state : S3 + DynamoDB lock, ne jamais commiter le state local
• Chiffrement : Server-side encryption sur S3
• Contrôle d'accès : Policies IAM restrictives pour le bucket de state
• Versioning : Activer le versioning pour la recovery
• State locking : DynamoDB pour empêcher les modifications concurrentes

Backend distant Terraform sécurisé

      terraform {
      backend "s3" {
      bucket         = "terraform-state-prod"
      key            = "global/s3/terraform.tfstate"
      region         = "us-east-1"
      encrypt        = true
      dynamodb_table = "terraform-state-lock"
      # MFA delete protection
      versioning {
      enabled = true
      mfa_delete = true
      }
      }
      }
      

CI/CD Integration

GitHub Actions - Workflow Terraform sécurisé

      name: 'Terraform Security Scan'
      on:
      pull_request:
      branches: [ main ]
      jobs:
      terraform-security:
      runs-on: ubuntu-latest
      steps:
      - uses: actions/checkout@v3
      - name: Run tfsec
      uses: aquasecurity/[email protected]
      with:
      soft_fail: false
      - name: Run Checkov
      uses: bridgecrewio/checkov-action@master
      with:
      directory: .
      framework: terraform
      output_format: sarif
      output_file_path: checkov.sarif
      - name: Upload results to GitHub Security
      uses: github/codeql-action/upload-sarif@v2
      with:
      sarif_file: checkov.sarif
      

Drift Detection

Détecter les changements manuels en dehors de l'IaC qui créent des failles de sécurité :

• Terraform Cloud : Health checks automatiques
• driftctl : Drift detection open-source
• CloudFormation Drift Detection : Service natif AWS
• Scheduled scans : Jobs CI/CD périodiques

Frameworks de Compliance

Modules Terraform sécurisés

• Utiliser des modules vérifiés du Terraform Registry
• Épingler les versions des modules (ne pas utiliser latest)
• Code review des modules internes
• Registry privé pour les modules personnalisés
• Documenter les considérations de sécurité

Bonnes pratiques

• Peer review : PRs obligatoires pour les changements en production
• Plan avant apply : Revue des changements proposés
• Separate environments : Dev/Staging/Prod isolés
• Stratégie de tagging : Tags pour la gouvernance et le cost allocation
• Least privilege : Rôles IAM spécifiques pour le CI/CD
• Automated testing : Terratest pour la validation