Terraform-Infrastruktur-Sicherheitsprüfung

Was macht Terraform-Infrastruktur-Sicherheitsprüfung?

Wann verwenden

• Beim Integrieren von Sicherheitsscans in CI/CD-Pipelines für Terraform-Deployments
• Beim Überprüfen von Terraform-Plänen und -Modulen auf Sicherheitsbest Practices vor dem Anwenden
• Beim Einrichten von Policy-as-Code-Schranken für die Cloud-Infrastrukturbereitstellung
• Beim Prüfen vorhandener Terraform-Statusdateien, um bereits deployte Fehlkonfigurationen zu identifizieren
• Beim Durchsetzen organisatorischer Sicherheitsstandards über mehrere Terraform-Projekte hinweg

Nicht verwenden für Runtime-Sicherheitsüberwachung (CSPM-Tools verwenden), für Anwendungssicherheitstests (SAST/DAST-Tools verwenden) oder für Erkennung von Cloud-Konfigurationsabweichungen (AWS Config oder Azure Policy nach dem Deployment verwenden).

Voraussetzungen

• Checkov installiert (pip install checkov)
• tfsec installiert (brew install tfsec oder Binary von GitHub)
• Terrascan installiert (brew install terrascan)
• Terraform v1.0+ für Plan-Erstellung
• OPA (Open Policy Agent) für benutzerdefinierte Richtliniendurchsetzung
• Git-Repository mit Terraform-Code zur Prüfung

Arbeitsablauf

Schritt 1: Terraform-Code mit Checkov scannen

Führen Sie Checkov für umfassende IaC-Sicherheitsscans mit integrierten und benutzerdefinierten Richtlinien aus.

# Ein Terraform-Verzeichnis scannen
checkov -d ./terraform/ --framework terraform

# Mit bestimmten Prüfkategorien scannen
checkov -d ./terraform/ --check CKV_AWS_18,CKV_AWS_19,CKV_AWS_20,CKV_AWS_21

# Ergebnisse als JSON ausgeben
checkov -d ./terraform/ --output json > checkov-results.json

# Eine Terraform-Plan-Datei für genauere Analyse scannen
terraform init && terraform plan -out=tfplan
terraform show -json tfplan > tfplan.json
checkov -f tfplan.json --framework terraform_plan

# Bestimmte Prüfungen mit Begründung überspringen
checkov -d ./terraform/ --skip-check CKV_AWS_145 \
  --bc-api-key $BRIDGECREW_API_KEY

# Terraform-Module scannen
checkov -d ./modules/ --framework terraform --compact

# Alle verfügbaren Prüfungen auflisten
checkov --list --framework terraform | grep CKV_AWS

Schritt 2: Mit tfsec auf terraformspezifische Probleme scannen

Verwenden Sie tfsec für eine Terraform-native Sicherheitsanalyse mit detaillierter Behebungsanleitung.

# Ein Terraform-Verzeichnis scannen
tfsec ./terraform/

# Mit minimalem Schweregradschwellwert scannen
tfsec ./terraform/ --minimum-severity HIGH

# Ausgabe im JSON-Format für CI/CD-Verarbeitung
tfsec ./terraform/ --format json > tfsec-results.json

# Mit benutzerdefinierten Prüfungen scannen
tfsec ./terraform/ --custom-check-dir ./custom-checks/

# Bestimmte Regeln ausschließen
tfsec ./terraform/ --exclude-downloaded-modules \
  --exclude aws-s3-enable-bucket-logging

# Scannen und bei bestimmten Schweregrad fehlschlagen lassen
tfsec ./terraform/ --minimum-severity CRITICAL --soft-fail

# SARIF-Ausgabe für den GitHub-Sicherheitstab generieren
tfsec ./terraform/ --format sarif > tfsec.sarif

Schritt 3: Terrascan für Multi-Framework-Compliance ausführen

Führen Sie Terrascan zur Compliance-Prüfung gegen CIS-, NIST- und SOC-2-Frameworks aus.

# Terraform gegen den CIS-AWS-Benchmark scannen
terrascan scan -t aws -i terraform -d ./terraform/ \
  --policy-type aws --verbose

# Gegen bestimmte Compliance-Frameworks scannen
terrascan scan -t aws -i terraform -d ./terraform/ \
  --policy-type aws \
  --categories "Compliance Validation"

# Ausgabe im JSON-Format
terrascan scan -t aws -i terraform -d ./terraform/ \
  --output json > terrascan-results.json

# Einen Terraform-Plan scannen
terrascan scan -t aws -i terraform \
  --iac-file tfplan.json \
  --iac-type tfplan

# Verfügbare Richtlinien auflisten
terrascan scan --list-policies -t aws

Schritt 4: Benutzerdefinierte OPA-Richtlinien für Organisationsstandards erstellen

Schreiben Sie Rego-Richtlinien für organisatorische Sicherheitsanforderungen.

# policy/aws_s3_encryption.rego
package terraform.aws.s3

deny[msg] {
    resource := input.resource.aws_s3_bucket[name]
    not resource.server_side_encryption_configuration
    msg := sprintf("S3-Bucket '%s' muss serverseitige Verschlüsselung aktiviert haben", [name])
}

# policy/aws_iam_no_wildcards.rego
package terraform.aws.iam

deny[msg] {
    resource := input.resource.aws_iam_policy[name]
    statement := resource.policy.Statement[_]
    statement.Action == "*"
    statement.Effect == "Allow"
    msg := sprintf("IAM-Richtlinie '%s' darf keine Wildcard-Aktionen (*) verwenden", [name])
}

deny[msg] {
    resource := input.resource.aws_iam_policy[name]
    statement := resource.policy.Statement[_]
    statement.Resource == "*"
    statement.Effect == "Allow"
    contains(statement.Action[_], "*")
    msg := sprintf("IAM-Richtlinie '%s' hat zu freizügige Aktionen auf Wildcard-Ressourcen", [name])
}

# policy/aws_no_public_ingress.rego
package terraform.aws.security_group

deny[msg] {
    resource := input.resource.aws_security_group_rule[name]
    resource.type == "ingress"
    resource.cidr_blocks[_] == "0.0.0.0/0"
    resource.from_port <= 22
    resource.to_port >= 22
    msg := sprintf("Security Group Regel '%s' erlaubt SSH von 0.0.0.0/0", [name])
}

# Terraform-Plan gegen OPA-Richtlinien auswerten
terraform show -json tfplan | opa eval \
  --data ./policy/ \
  --input /dev/stdin \
  "data.terraform.aws" \
  --format pretty

# Conftest für einfachere OPA-Richtlinientests ausführen
conftest test tfplan.json --policy ./policy/ --output json

Schritt 5: Sicherheitsscan in CI/CD-Pipeline integrieren

Fügen Sie IaC-Sicherheitsscans als obligatorisches CI/CD-Gate hinzu.

# GitHub Actions: Terraform-Sicherheitspipeline
name: Terraform Security Scan
on:
  pull_request:
    paths: ['terraform/**']

jobs:
  security-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Terraform
        uses: hashicorp/setup-terraform@v3

      - name: Terraform Init & Plan
        run: |
          cd terraform/
          terraform init
          terraform plan -out=tfplan
          terraform show -json tfplan > tfplan.json

      - name: Checkov Scan
        uses: bridgecrewio/checkov-action@master
        with:
          directory: terraform/
          framework: terraform
          output_format: sarif
          output_file_path: checkov.sarif
          soft_fail: false

      - name: tfsec Scan
        uses: aquasecurity/[email protected]
        with:
          working_directory: terraform/
          soft_fail: false

      - name: Upload SARIF
        uses: github/codeql-action/upload-sarif@v2
        with:
          sarif_file: checkov.sarif

      - name: OPA Policy Check
        run: |
          conftest test terraform/tfplan.json \
            --policy ./policy/ \
            --output json

Schritt 6: Terraform-Status auf bereits deployte Fehlkonfigurationen scannen

Prüfen Sie den aktuellen Terraform-Status auf bereits deployte Sicherheitsprobleme.

# Aktuellen Status als JSON exportieren
terraform show -json > terraform-state.json

# Status mit Checkov scannen
checkov -f terraform-state.json --framework terraform_plan

# Status nach bestimmten Sicherheitsproblemen durchsuchen
terraform state list | while read resource; do
  terraform state show "$resource" 2>/dev/null | grep -i "public\|0.0.0.0\|encrypt.*false\|password"
done

# Ressourcen ohne erforderliche Tags finden
terraform state list | grep aws_instance | while read resource; do
  tags=$(terraform state show "$resource" | grep -A20 "tags")
  if ! echo "$tags" | grep -q "Environment"; then
    echo "FEHLENDER TAG: $resource besitzt keinen 'Environment'-Tag"
  fi
done

Schlüsselkonzepte

Begriff	Definition
Infrastructure as Code	Praxis der Verwaltung von Cloud-Infrastruktur durch deklarative Konfigurationsdateien (Terraform, CloudFormation) anstatt manueller Konsolenoperationen
Policy as Code	Ausdrücken von Sicherheits- und Compliance-Richtlinien als ausführbarer Code (Rego, Python), der automatisch gegen Infrastrukturdefinitionen ausgewertet werden kann
Shift Left Security	Sicherheitsprüfungen früher im Entwicklungslebenszyklus durchführen, indem IaC vor dem Deployment gescannt wird, anstatt nach der Bereitstellung zu prüfen
Terraform Plan	Vorschau der Änderungen, die Terraform vornehmen wird; kann als JSON für Sicherheitsscans vor dem Anwenden exportiert werden
Checkov	Open-Source-Statikanalysewerkzeug für IaC mit Unterstützung für Terraform, CloudFormation, Kubernetes und Docker mit über 1.000 integrierten Richtlinien
OPA/Rego	Open Policy Agent und seine Richtliniensprache Rego zum Definieren benutzerdefinierter Sicherheitsregeln, die gegen strukturierte Dateneingaben ausgewertet werden

Werkzeuge und Systeme

• Checkov: Umfassender IaC-Scanner mit über 1.000 Richtlinien für Terraform, CloudFormation, Kubernetes, ARM und Dockerfile
• tfsec: Terraform-spezifisches Statikanalysewerkzeug mit detaillierter Behebungsanleitung und SARIF-Ausgabe
• Terrascan: Multi-IaC-Scanner mit Unterstützung für Compliance-Frameworks (CIS, NIST, SOC 2) und Policy-as-Code
• OPA/Conftest: Benutzerdefinierte Richtlinien-Engine zum Definieren organisationsspezifischer Sicherheitsregeln mit der Rego-Sprache
• Bridgecrew: Kommerzielle Plattform auf Basis von Checkov mit Abweichungserkennung und Supply-Chain-Sicherheit

Häufige Szenarien

Szenario: Sicherheitsgates zu einer bestehenden Terraform-CI/CD-Pipeline hinzufügen

Kontext: Ein DevOps-Team stellt Infrastruktur über Terraform in GitHub Actions bereit, hat aber keine Sicherheitsscans. Aktuelle Audit-Ergebnisse zeigen mehrere S3-Buckets ohne Verschlüsselung und Security Groups, die SSH aus dem Internet erlauben.

Vorgehen:

1. Checkov als erstes Sicherheitsgate im GitHub Actions-Workflow hinzufügen
2. checkov -d ./terraform/ ausführen, um die aktuelle Basis an Fundstellen zu ermitteln
3. Vorhandene Fundstellen priorisieren: KRITISCHE Probleme beheben, Tickets für HOHE erstellen, akzeptierte Risiken unterdrücken
4. tfsec als sekundären Scanner für terraformspezifische Prüfungen hinzufügen
5. Benutzerdefinierte OPA-Richtlinien für Organisationsstandards schreiben (erforderliche Tags, Namenskonventionen)
6. Pipeline so konfigurieren, dass sie PRs mit KRITISCHEN oder HOHEN Fundstellen blockiert
7. SARIF-Berichte für die Integration in den GitHub-Sicherheitstab erstellen

Fallstricke: Das Hinzufügen von Sicherheitsscans zu einem bestehenden Projekt wird anfangs Hunderte von Fundstellen erzeugen. Graduell implementieren, indem zunächst nur KRITISCHE Fundstellen blockiert werden, dann auf HOHE erweitern. Inline-Unterdrückungskommentare (#checkov:skip=CKV_AWS_18:Öffentlicher Bucket für statische Website) für beabsichtigte Ausnahmen mit dokumentierter Begründung verwenden.

Ausgabeformat

Terraform Security Audit Report
==================================
Repository: acme-corp/infrastructure
Branch: main
Scan-Datum: 2026-02-23
Werkzeuge: Checkov 3.x, tfsec 1.x, OPA benutzerdefinierte Richtlinien

SCAN-ERGEBNISSE:
  Checkov-Prüfungen bestanden:    187
  Checkov-Prüfungen fehlgeschlagen: 34
  tfsec-Prüfungen bestanden:      156
  tfsec-Prüfungen fehlgeschlagen: 28
  OPA benutzerdefinierte Richtlinien: 12 bestanden, 3 fehlgeschlagen

KRITISCHE FUNDSTELLEN:
[TF-001] S3-Bucket ohne Verschlüsselung
  Datei: modules/storage/main.tf:24
  Ressource: aws_s3_bucket.data_lake
  Prüfung: CKV_AWS_19
  Behebung: server_side_encryption_configuration-Block hinzufügen

[TF-002] Security Group erlaubt SSH von 0.0.0.0/0
  Datei: modules/network/security.tf:45
  Ressource: aws_security_group_rule.ssh_access
  Prüfung: CKV_AWS_24
  Behebung: cidr_blocks auf Bastion-Subnetz einschränken

[TF-003] IAM-Richtlinie mit Wildcard-Aktionen
  Datei: modules/iam/policies.tf:12
  Ressource: aws_iam_policy.developer_policy
  Prüfung: CKV_AWS_1
  Behebung: Aktionen auf die erforderlichen spezifischen Dienste eingrenzen

ZUSAMMENFASSUNG NACH SCHWEREGRAD:
  Kritisch:  6 Fundstellen
  Hoch:     14 Fundstellen
  Mittel:   28 Fundstellen
  Niedrig:  18 Fundstellen
  Info:     12 Fundstellen