TD3 – Gestion des secrets, chiffrement et traçabilité AWS

• Supprimer les secrets en clair dans une infrastructure Terraform
• Utiliser AWS Secrets Manager pour stocker des identifiants sensibles
• Activer le chiffrement des données au repos sur RDS et S3
• Comprendre la différence entre chiffrement au repos et en transit
• Mettre en place une traçabilité avec CloudTrail
• Identifier une action suspecte via les logs

Suite au TD2, l'infrastructure réseau est opérationnelle.

Le VPC est segmenté, l'ALB filtre le trafic entrant, les Security Groups isolent chaque couche.

Un nouvel audit de sécurité interne est réalisé.

Trois failles critiques sont identifiées malgré les corrections du TD2 :

• le mot de passe de la base de données est stocké en clair dans `instances.tf`
• la base de données RDS n'est pas chiffrée au repos
• aucune trace des actions réalisées sur le compte AWS n'est conservée

Ces trois points constituent des non-conformités bloquantes pour toute certification de sécurité (ISO 27001, SOC 2, RGPD).

Votre mission est de corriger ces trois failles en prolongeant l'infrastructure du TD2.

• Projet Terraform du TD2 déployé et fonctionnel
• ALB opérationnel, Security Groups en place
• Accès AWS avec droits suffisants : IAM, Secrets Manager, S3, RDS, CloudTrail
• Terraform en version 1.5 ou supérieure

Le TD3 s'appuie sur les ressources existantes du TD2 et ajoute trois nouveaux modules.

td3/
├── main.tf
├── variables.tf
├── outputs.tf
├── providers.tf
└── modules/
    ├── secrets/
    │   └── main.tf
    ├── database/
    │   └── main.tf
    ├── storage/
    │   └── main.tf
    └── logging/
        └── main.tf

Le dossier `td2/` n'est pas modifié directement.

Les ressources existantes du TD2 sont récupérées via des data sources Terraform.

Le module `storage` utilisera le provider `random` pour générer des suffixes uniques sur les noms de buckets S3.

Les noms de buckets S3 sont globaux sur AWS : deux comptes ne peuvent pas avoir le même nom.

Fichier : `td3/providers.tf`

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~> 3.0"
    }
  }
}

provider "aws" {
  region = "eu-west-3"
}

Le mot de passe initial doit être injecté au moment de l'exécution.

Il ne doit jamais apparaître dans un fichier `.tf`.

Fichier : `td3/variables.tf`

variable "db_initial_password" {
  description = "Mot de passe initial de la base de donnees. Injecte via tfvars ou variable d'environnement."
  type        = string
  sensitive   = true
}

Fichier : `td3/terraform.tfvars`

db_initial_password = "InitialPass123!"

Fichier : `td3/.gitignore`

*.tfvars
*.tfstate
*.tfstate.backup
.terraform/
.terraform.lock.hcl

Plutôt que de recréer les ressources, on les référence via des data sources.

Fichier : `td3/main.tf`

# Recuperation du VPC existant du TD2
data "aws_vpc" "td2" {
  filter {
    name   = "tag:Name"
    values = ["td2-vpc"]
  }
}

# Recuperation du Security Group du backend TD2
data "aws_security_group" "backend" {
  filter {
    name   = "tag:Name"
    values = ["backend-sg"]
  }
  vpc_id = data.aws_vpc.td2.id
}

# Recuperation du subnet group RDS existant
data "aws_db_subnet_group" "main" {
  name = "td2-db-subnet-group"
}

Objectif : stocker le mot de passe dans AWS Secrets Manager, pas dans le code.

Fichier : `td3/modules/secrets/main.tf`

variable "db_password" {
  type      = string
  sensitive = true
}

resource "aws_secretsmanager_secret" "db_credentials" {
  name                    = "td3/database/credentials"
  description             = "Identifiants de la base de donnees TD3"
  recovery_window_in_days = 0
}

resource "aws_secretsmanager_secret_version" "db_credentials" {
  secret_id = aws_secretsmanager_secret.db_credentials.id

  secret_string = jsonencode({
    username = "td3admin"
    password = var.db_password
  })
}

output "secret_arn" {
  description = "ARN du secret a transmettre au module database"
  value       = aws_secretsmanager_secret.db_credentials.arn
}

Fichier : `td3/main.tf` — ajouter après les data sources

module "secrets" {
  source      = "./modules/secrets"
  db_password = var.db_initial_password
}

Objectif : remplacer la ressource RDS du TD2 par une version sécurisée.

La dépendance entre le secret et la base est gérée implicitement via le passage de l'ARN en variable.

Terraform comprend qu'il doit créer le secret avant de lire son contenu car la valeur vient d'un output du module `secrets`.

Fichier : `td3/modules/database/main.tf`

variable "secret_arn" {
  type        = string
  description = "ARN du secret contenant les identifiants de la base"
}

variable "db_subnet_group_name" {
  type        = string
  description = "Nom du subnet group RDS existant"
}

variable "vpc_security_group_ids" {
  type        = list(string)
  description = "Liste des Security Group IDs autorises a acceder a la base"
}

data "aws_secretsmanager_secret_version" "db_credentials" {
  secret_id = var.secret_arn
}

locals {
  db_creds = jsondecode(data.aws_secretsmanager_secret_version.db_credentials.secret_string)
}

resource "aws_db_instance" "main" {
  identifier        = "td3-database"
  engine            = "postgres"
  engine_version    = "15"
  instance_class    = "db.t3.micro"
  allocated_storage = 20

  db_name  = "td3app"
  username = local.db_creds["username"]
  password = local.db_creds["password"]

  db_subnet_group_name   = var.db_subnet_group_name
  vpc_security_group_ids = var.vpc_security_group_ids

  storage_encrypted   = true
  skip_final_snapshot = true

  tags = {
    Name = "td3-database"
  }
}

output "db_endpoint" {
  description = "Endpoint de connexion a la base de donnees"
  value       = aws_db_instance.main.endpoint
}

Fichier : `td3/main.tf` — ajouter après le module secrets

module "database" {
  source      = "./modules/database"
  secret_arn  = module.secrets.secret_arn

  db_subnet_group_name   = data.aws_db_subnet_group.main.name
  vpc_security_group_ids = [data.aws_security_group.backend.id]
}

Objectif : créer un bucket S3 avec chiffrement et blocage des accès publics.

Fichier : `td3/modules/storage/main.tf`

resource "random_id" "bucket_suffix" {
  byte_length = 4
}

resource "aws_s3_bucket" "secure_data" {
  bucket = "td3-secure-data-${random_id.bucket_suffix.hex}"

  tags = {
    Name = "td3-secure-data"
  }
}

resource "aws_s3_bucket_server_side_encryption_configuration" "secure_data" {
  bucket = aws_s3_bucket.secure_data.id

  rule {
    apply_server_side_encryption_by_default {
      sse_algorithm = "AES256"
    }
    bucket_key_enabled = true
  }
}

resource "aws_s3_bucket_public_access_block" "secure_data" {
  bucket = aws_s3_bucket.secure_data.id

  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

output "bucket_name" {
  description = "Nom du bucket S3 securise"
  value       = aws_s3_bucket.secure_data.id
}

Fichier : `td3/main.tf` — ajouter après le module database

module "storage" {
  source = "./modules/storage"
}

Objectif : tracer toutes les actions réalisées sur le compte AWS via CloudTrail.

CloudTrail écrit ses logs dans un bucket S3 dédié.

AWS exige une policy bucket explicite pour autoriser CloudTrail à écrire.

Sans cette policy, la ressource `aws_cloudtrail` échoue au déploiement.

Fichier : `td3/modules/logging/main.tf`

data "aws_caller_identity" "current" {}

resource "aws_s3_bucket" "cloudtrail_logs" {
  bucket = "td3-cloudtrail-${data.aws_caller_identity.current.account_id}"

  tags = {
    Name = "td3-cloudtrail-logs"
  }
}

resource "aws_s3_bucket_public_access_block" "cloudtrail_logs" {
  bucket = aws_s3_bucket.cloudtrail_logs.id

  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

resource "aws_s3_bucket_policy" "cloudtrail_logs" {
  bucket = aws_s3_bucket.cloudtrail_logs.id

  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Sid    = "AWSCloudTrailAclCheck"
        Effect = "Allow"
        Principal = {
          Service = "cloudtrail.amazonaws.com"
        }
        Action   = "s3:GetBucketAcl"
        Resource = aws_s3_bucket.cloudtrail_logs.arn
      },
      {
        Sid    = "AWSCloudTrailWrite"
        Effect = "Allow"
        Principal = {
          Service = "cloudtrail.amazonaws.com"
        }
        Action   = "s3:PutObject"
        Resource = "${aws_s3_bucket.cloudtrail_logs.arn}/AWSLogs/${data.aws_caller_identity.current.account_id}/*"
        Condition = {
          StringEquals = {
            "s3:x-amz-acl" = "bucket-owner-full-control"
          }
        }
      }
    ]
  })

  depends_on = [aws_s3_bucket_public_access_block.cloudtrail_logs]
}

resource "aws_cloudtrail" "main" {
  name                          = "td3-audit-trail"
  s3_bucket_name                = aws_s3_bucket.cloudtrail_logs.id
  include_global_service_events = true
  is_multi_region_trail         = false
  enable_log_file_validation    = true

  tags = {
    Name = "td3-audit-trail"
  }

  depends_on = [aws_s3_bucket_policy.cloudtrail_logs]
}

output "cloudtrail_name" {
  description = "Nom du trail CloudTrail actif"
  value       = aws_cloudtrail.main.name
}

Fichier : `td3/main.tf` — ajouter en dernier

module "logging" {
  source = "./modules/logging"
}

Fichier : `td3/outputs.tf`

output "db_endpoint" {
  description = "Endpoint de la base de donnees TD3"
  value       = module.database.db_endpoint
}

output "secure_bucket_name" {
  description = "Nom du bucket S3 securise"
  value       = module.storage.bucket_name
}

output "cloudtrail_name" {
  description = "Nom du trail CloudTrail actif"
  value       = module.logging.cloudtrail_name
}

Objectif : vérifier que CloudTrail trace bien les actions réalisées sur le compte.

cd td2/
terraform apply

CloudTrail > Event history

cd td2/
terraform apply

Axe secrets

Axe chiffrement

Axe traçabilité

Axe architecture

Rotation automatique des secrets

Fichier : `td3/modules/secrets/main.tf` — ajouter après la ressource `aws_secretsmanager_secret_version`

variable "rotation_lambda_arn" {
  type        = string
  description = "ARN de la Lambda de rotation fournie par AWS pour PostgreSQL"
  default     = ""
}

resource "aws_secretsmanager_secret_rotation" "db_credentials" {
  count               = var.rotation_lambda_arn != "" ? 1 : 0
  secret_id           = aws_secretsmanager_secret.db_credentials.id
  rotation_lambda_arn = var.rotation_lambda_arn

  rotation_rules {
    automatically_after_days = 30
  }
}