Vérifier les ID d’AMI AWS dans Terraform avec Regula et Open Policy Agent

La semaine dernière, nous avons annoncé Fugue IaC, qui permet aux équipes d’ingénierie cloud de sécuriser leur infrastructure as code (IaC) et leur environnement d’exécution cloud à l’aide des mêmes politiques. Pour exécuter des vérifications IaC en local, Fugue a développé Regula, un outil open source basé sur Open Policy Agent (OPA).

Regula peut être utilisé avec ou sans Fugue. Il comprend des centaines de règles prêtes à l’emploi conçues pour vérifier l’infrastructure as code (IaC) Terraform et CloudFormation, ainsi que les manifestes Kubernetes. Ces règles sont associées aux CIS Benchmarks et couvrent de nombreuses vulnérabilités de sécurité.

Mais vous pouvez parfois vouloir appliquer des politiques propres à votre organisation, par exemple exiger que les instances Amazon EC2 utilisent des AMI approuvées. Dans ce cas, vous pouvez écrire une règle personnalisée dans le langage Rego d’OPA, que Regula appliquera à votre IaC. Ainsi, si votre IaC déclare une AMI non approuvée, la vérification Regula échoue.

Dans cet article :

• Nous allons écrire une règle personnalisée pour vérifier les AMI AWS EC2 déclarées dans Terraform, en expliquant le code Rego ligne par ligne.

• Nous utiliserons notre outil open source Regula pour tester la règle sur un fichier Terraform non conforme.

• Nous corrigerons le fichier Terraform non conforme.

Notez que cet article utilise Regula pour vérifier le HCL de Terraform, mais que vous pouvez aussi utiliser exactement la même règle personnalisée avec le SaaS Fugue pour vérifier les ressources cloud en environnement d’exécution. C’est possible grâce au moteur de politiques unifié de Fugue, qui permet d’utiliser les mêmes règles pour l’IaC et l’environnement d’exécution.

Vous trouverez tout le code dans ce gist GitHub.

C’est parti !

Pour commencer

Télécharger les fichiers de code

Dans notre gist GitHub, cliquez sur le bouton Download ZIP, puis extrayez les fichiers. Vous trouverez deux fichiers :

• approved_ami.rego – une règle personnalisée écrite en Rego

• ami.tf – un fichier HCL Terraform qui déclare deux instances EC2, l’une conforme et l’autre non conforme

Installer Regula

L’étape suivante consiste à installer Regula, si ce n’est pas déjà fait. Si vous utilisez Homebrew, exécutez les commandes suivantes dans votre terminal :

brew tap fugue/regula
brew install regula

Vous pouvez également installer un binaire précompilé pour votre plateforme ou, si vous préférez, exécuter Regula avec Docker.

Écrire la règle personnalisée

Commençons par déterminer le type de règle à écrire. Regula propose deux types de règles : simples et avancées. Les règles simples sont utiles pour vérifier un seul type de ressource. Les règles avancées sont plus adaptées à une logique complexe impliquant plusieurs ressources ou à la recherche de ressources manquantes.

Nous allons vérifier un seul type de ressource Terraform, aws_instance : nous écrirons donc une règle simple.

Déclaration de package

Commençons par les bases. Toutes les règles Regula doivent comporter une déclaration de package commençant par rules. et se terminant par un identifiant court (ligne 4) :

4package rules.approved_ami

Métadonnées

Vous pouvez ajouter des métadonnées, si vous le souhaitez (lignes 6 à 18) :

6__rego__metadoc__ := {
7  "id": "CUSTOM_0002",
8  "title": "AWS EC2 instances must use approved AMIs",
9  "description": "Per company policy, EC2 instances may only use AMI IDs from a pre-approved list",
10  "custom": {
11    "controls": {
12      "CORPORATE-POLICY": [
13        "CORPORATE-POLICY_1.2"
14      ]
15    },
16    "severity": "High"
17  }
18}

Ce n’est pas obligatoire, mais cela rend les rapports de Regula encore plus informatifs.

Type de ressource

Ensuite, indiquons le type de ressource Terraform à vérifier (ligne 20) :

20resource_type = "aws_instance"

Cette syntaxe indique que l’entrée sera une seule instance AWS EC2. Lorsque Regula appliquera la règle à notre fichier Terraform, il évaluera une instance à la fois.

Ensemble d’AMI approuvées

Pour simplifier, supposons que votre organisation ait approuvé ces deux ID d’AMI :

• ami-09e67e426f25ce0d7

• ami-03d5c68bab01f3496

(Pour les curieux, ce sont les ID d’Ubuntu Server 20.04 LTS HVM, SSD Volume Type dans us-east-1 et us-west-2, respectivement.)

Créons maintenant un ensemble contenant les ID des AMI approuvées. Nous l’appellerons approved_amis (lignes 22 à 26) :

22approved_amis = {
23  # Ubuntu Server 20.04 LTS (HVM), SSD Volume Type
24  "ami-09e67e426f25ce0d7", # us-east-1
25  "ami-03d5c68bab01f3496" # us-west-2 
26}

La règle deny

Enfin, nous allons écrire une règle deny. C’est là que se trouve la logique principale ! La règle deny définit les conditions dans lesquelles une ressource doit échouer à la vérification.

Nous allons faire un peu plus sophistiqué et renvoyer un message d’erreur personnalisé qui indique l’ID de l’AMI non approuvée lorsqu’une instance échoue à la vérification Regula.

Notre règle deny doit vérifier si l’ID d’AMI de l’instance en cours d’évaluation figure dans l’ensemble des AMI approuvées. Si ce n’est pas le cas, deny doit renvoyer un message d’erreur pour cette ressource (c’est-à-dire produire un résultat d’échec). deny est défini aux lignes 28 à 31 :

28deny[msg] {
29  not approved_amis[input.ami]
30  msg = sprintf("%s is not an approved AMI ID", [input.ami])
31}

Examinons la logique de plus près :

29not approved_amis[input.ami]

input.ami représente l’attribut ami de chaque instance EC2 dans le document d’entrée (votre fichier HCL Terraform — ou, plus précisément, sa représentation JSON que Regula transforme en coulisses).

not approved_amis[input.ami] renvoie true si l’attribut ami de l’instance actuelle ne fait pas partie de l’ensemble.

En résumé, la règle deny indique : « Si input.ami ne figure pas dans approved_amis, la vérification Regula doit échouer et renvoyer un message d’erreur. »

Nous définissons le message d’erreur sur cette ligne :

msg = sprintf("%s is not an approved AMI ID", [input.ami])

Cette ligne utilise la fonction Rego intégrée sprintf pour afficher l’ami de la ressource en cours d’évaluation.

Et voilà notre règle personnalisée ! La voici dans son intégralité. Il est temps de tester Regula !

Exécuter la règle personnalisée avec Regula

Testons maintenant la règle sur un fichier Terraform simple. Le HCL Terraform de notre gist GitHub définit deux instances EC2 : une instance « valide » avec l’ID d’AMI approuvée ami-09e67e426f25ce0d7 et une instance « non valide » avec l’ID d’AMI absolument pas suspect ami-totallylegitamiid.

Exécuter Regula

Dans votre terminal, utilisez cd pour accéder au répertoire contenant les fichiers de code, puis exécutez la commande suivante :

regula run ami.tf --include approved_ami.rego --user-only

Cette commande applique notre règle personnalisée au fichier Terraform. L’option --user-only indique qu’il faut appliquer uniquement la règle personnalisée ; pour cet article, nous excluons la bibliothèque de règles intégrées de Regula. (Il est toutefois recommandé d’utiliser les règles intégrées, incluses par défaut lorsque vous exécutez regula run.)

Voici le résultat obtenu :

Comme vous pouvez le constater, notre fichier Terraform a échoué à la vérification avec le message ami-totallylegitamiid is not an approved AMI ID. C’est parfait : cela signifie que notre règle personnalisée fonctionne ! Regula nous a indiqué que l’instance aws_instance.bad (ligne 13, colonne 1) n’avait pas d’ID d’AMI approuvée.

Afficher un rapport plus détaillé

Pour obtenir plus de détails, examinons le rapport complet, au format JSON :

regula run ami.tf --include approved_ami.rego --user-only --format json

Nous pouvons voir ici le résultat complet, y compris tous les résultats des règles. Notez ci-dessous que aws_instance.bad obtient à nouveau le résultat FAIL, tandis que aws_instance.good obtient le résultat PASS :

{
  "rule_results": [
    {
      "controls": [
        "CORPORATE-POLICY_1.2"
      ],
      "filepath": "ami.tf",
      "input_type": "tf",
      "provider": "aws",
      "resource_id": "aws_instance.bad",
      "resource_type": "aws_instance",
      "rule_description": "Per company policy, EC2 instances may only use AMI IDs from a pre-approved list",
      "rule_id": "CUSTOM_0002",
      "rule_message": "ami-totallylegitamiid is not an approved AMI ID",
      "rule_name": "approved_ami",
      "rule_result": "FAIL",
      "rule_severity": "High",
      "rule_summary": "AWS EC2 instances must use approved AMIs",
      "source_location": [
        {
          "path": "ami.tf",
          "line": 13,
          "column": 1
        }
      ]
    },
    {
      "controls": [
        "CORPORATE-POLICY_1.2"
      ],
      "filepath": "ami.tf",
      "input_type": "tf",
      "provider": "aws",
      "resource_id": "aws_instance.good",
      "resource_type": "aws_instance",
      "rule_description": "Per company policy, EC2 instances may only use AMI IDs from a pre-approved list",
      "rule_id": "CUSTOM_0002",
      "rule_message": "",
      "rule_name": "approved_ami",
      "rule_result": "PASS",
      "rule_severity": "High",
      "rule_summary": "AWS EC2 instances must use approved AMIs",
      "source_location": [
        {
          "path": "ami.tf",
          "line": 8,
          "column": 1
        }
      ]
    }
  ],
  "summary": {
    "filepaths": [
      "ami.tf"
    ],
    "rule_results": {
      "FAIL": 1,
      "PASS": 1,
      "WAIVED": 0
    },
    "severities": {
      "Critical": 0,
      "High": 1,
      "Informational": 0,
      "Low": 0,
      "Medium": 0,
      "Unknown": 0
    }
  }
}

Vous pouvez également consulter le reste des métadonnées que nous avons définies précédemment dans la règle.

Corriger le fichier Terraform

Pour rendre le fichier Terraform conforme, vous pouvez modifier ami.tf et remplacer ami-totallylegitamiid par ami-09e67e426f25ce0d7, puis exécuter Regula à nouveau. Cette fois, nous utiliserons le format texte par défaut :

regula run ami.tf --include approved_ami.rego --user-only

Voici le résultat obtenu :

No problems found.

C’est réussi ! Regula confirme que nous avons sécurisé notre IaC Terraform en utilisant uniquement des AMI approuvées.

Pour aller plus loin

Dans cet article, nous avons écrit une règle personnalisée en Rego, utilisé Regula pour la vérifier sur un fichier HCL Terraform et rendu le fichier Terraform conforme.

Pour en savoir plus sur Regula, consultez le site de documentation de Regula. Les ressources suivantes pourraient vous être utiles :

• Écrire des règles

• Exemple : écrire une règle simple

• Utilisation