Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Korrelierte Bedrohungen testen

Auf dieser Seite wird beschrieben, wie Sie prüfen können, ob Correlated Threats funktioniert. Dazu werden Bedrohungen emuliert, um Security Command Center-Detektoren auszulösen und Ergebnisse zu erstellen. Diese Bedrohungsergebnisse führen dann zu Problemen mit Correlated Threats für jede Regel.

Weitere Informationen zu Correlated Threats finden Sie in der Übersicht zu Correlated Threats Correlated Threats. Wenn Sie Ergebnisse generieren möchten, die zu Problemen mit Correlated Threats führen, müssen Sie die entsprechenden Dienste zur Bedrohungserkennung in den Security Command Center Einstellungen aktivieren.

Umgebung einrichten

Für diese Testverfahren sind sowohl ein GKE-Cluster als auch die Möglichkeit zur Bereitstellung von Compute Engine-VMs erforderlich. Achten Sie darauf, dass sich Ihr Testcluster in einer unterstützten Version von Google Kubernetes Engine (GKE) befindet. Weitere Informationen finden Sie unter Unterstützte GKE-Version verwenden.

Bevor Sie Correlated Threats testen, müssen Sie zuerst ein Projekt mit dem entsprechenden GKE-Cluster auswählen, Cloud Shell aktivieren und mehrere Umgebungsvariablen festlegen. Gehen Sie hierzu folgendermaßen vor:

Rufen Sie die Google Cloud Console auf.

Rufen Sie die Google Cloud Console auf.
Wählen Sie das Projekt aus, in dem Sie Correlated Threats testen möchten.
Klicken Sie auf Google Cloud Shell aktivieren.

Legen Sie in Cloud Shell Umgebungsvariablen fest:

Geben Sie das Projekt, die Zone und den GKE-Cluster an, die für Tests verwendet werden sollen:
```
export PROJECT=PROJECT_ID
export ZONE=ZONE
export CLUSTER_NAME=CLUSTER_NAME
```

Rufen Sie die Anmeldedaten für Ihren Cluster ab:

gcloud container clusters get-credentials $CLUSTER_NAME \
    --zone $ZONE \
    --project $PROJECT

Kryptowährungs-Mining-Angriff emulieren

In diesem Abschnitt wird beschrieben, wie Sie Kryptowährungs-Mining emulieren und ein Problem mit Correlated Threats über die Google Cloud Console und Cloud Shell erstellen. Dazu aktivieren Sie zuerst Cloud Shell, wählen ein Projekt aus und führen dann den Test aus.

So testen Sie Correlated Threats, indem Sie Kryptowährungs-Mining emulieren:

Umgebung einrichten

Um ein Problem mit Correlated Threats für Kryptowährungen auszulösen, erstellen Sie zwei Ergebnisse: Impact: suspicious crypto mining activity using the stratum protocol und Malware: Cryptomining Bad IP. Führen Sie die folgenden Befehle aus, um diese beiden Ergebnisse auszulösen:

tag="correlated-threat-test-crypto-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
kubectl run \
     --restart=Never \
     --image marketplace.gcr.io/google/ubuntu2404:latest \
     "$tag" -- bash -c \
     "apt-get update ; apt-get install -y curl ; cp /bin/ls /tmp/curl; /tmp/curl --url=stratum+tcp ; for i in {1..5}; do curl 34.66.147.47 > /dev/null; done; sleep infinity"

Es kann bis zu einer Stunde dauern, bis das Problem mit Correlated Threats angezeigt wird.

Nachdem das Problem mit Correlated Threats generiert wurde, führen Sie eine Bereinigung durch, indem Sie den folgenden Befehl ausführen, um den für Tests verwendeten Kubernetes-Pod zu löschen.
```
kubectl delete pod "$tag"
```

Malware-Angriff emulieren

In diesem Abschnitt wird beschrieben, wie Sie einen Malware-Angriff emulieren und ein Problem mit Correlated Threats über die Google Cloud Console und Cloud Shell erstellen. Dazu aktivieren Sie zuerst Cloud Shell, wählen ein Projekt aus und führen dann den Test aus.

So testen Sie Correlated Threats, indem Sie einen Malware-Angriff emulieren:

Umgebung einrichten.

Um ein Problem mit Correlated Threats für Malware auszulösen, erstellen Sie zwei Ergebnisse: Execution: Local Reconnaissance Tool Execution und Execution: Added Malicious Binary Executed. Führen Sie die folgenden Befehle aus, um einen Ubuntu 24.04-Pod in Ihrem GKE-Cluster zu erstellen und diese beiden Ergebnisse auszulösen:

tag="correlated-threat-test-malware-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
eicar='X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*'
kubectl run \
     --restart=Never \
     --image marketplace.gcr.io/google/ubuntu2404:latest \
     "$tag" -- sh -c \
     "cp /bin/ls /tmp/linenum.sh; /tmp/linenum.sh; touch /tmp/test_mal_file; echo -n '$eicar' > /tmp/test_mal_file; chmod 700 /tmp/test_mal_file; /tmp/test_mal_file; sleep infinity"

Es kann bis zu einer Stunde dauern, bis das Problem mit Correlated Threats angezeigt wird.

Nachdem das Problem mit Correlated Threats generiert wurde, führen Sie eine Bereinigung durch, indem Sie den folgenden Befehl ausführen, um den für Tests verwendeten Kubernetes-Pod zu löschen.
```
kubectl delete pod "$tag"
```

Lateral Movement-Angriff auf GKE emulieren

In diesem Abschnitt wird beschrieben, wie Sie einen Lateral Movement-Angriff auf GKE emulieren und ein Problem mit Correlated Threats über die Google Cloud Console und Cloud Shell erstellen. Dazu aktivieren Sie zuerst Cloud Shell, wählen ein Projekt aus und führen dann den Test aus.

So testen Sie Correlated Threats, indem Sie einen Lateral Movement-Angriff emulieren: Führen Sie die folgenden Schritte aus:

Umgebung einrichten.
Um ein Problem mit Correlated Threats für Lateral Movement auszulösen, erstellen Sie zwei Ergebnisse: Privilege Escalation: Launch of privileged Kubernetes container und Execution: Container Escape. Führen Sie die folgenden Befehle aus, um einen Ubuntu-Pod in Ihrem GKE-Cluster zu erstellen und diese beiden Ergebnisse auszulösen:
```
tag="correlated-threat-test-podlatmove-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
kubectl run \
     --restart=Never \
     --image marketplace.gcr.io/google/ubuntu2404:latest "$tag" \
     --privileged \
     -- bash -c \
        "cp /bin/ls /tmp/botb-linux-amd64; sleep 300; /tmp/botb-linux-amd64 -autopwn; sleep infinity"
```
Es kann bis zu einer Stunde dauern, bis das Problem mit Correlated Threats angezeigt wird.
Nachdem das Problem mit Correlated Threats generiert wurde, führen Sie eine Bereinigung durch, indem Sie den folgenden Befehl ausführen, um den für Tests verwendeten Kubernetes-Pod zu löschen.
```
kubectl delete pod "$tag"
```

Lateral Movement-Angriff auf Compute Engine emulieren

In diesem Abschnitt wird beschrieben, wie Sie einen Lateral Movement-Angriff auf Compute Engine emulieren und ein Problem mit Correlated Threats über die Google Cloud Console und Cloud Shell erstellen. Dazu aktivieren Sie zuerst Cloud Shell, wählen ein Projekt aus und führen dann den Test aus.

So testen Sie Correlated Threats, indem Sie einen Lateral Movement-Angriff emulieren:

Umgebung einrichten.

Erstellen Sie eine Datei mit dem Namen lateral_movement_test.sh und folgendem Inhalt. Dieses Skript erstellt mehrere Compute Engine-VMs und generiert die folgenden zwei Ergebnisse: Lateral Movement: Modified Boot Disk Attached to Instance und Malware: Bad IP.

#!/bin/bash
# emulates a boot disk swap followed by malicious IP to trigger correlated threats.

set -euo pipefail

# --- Default values ---
readonly IMAGE_FAMILY="debian-12"
readonly IMAGE_PROJECT="debian-cloud"
TIMESTAMP=$(date +%s)
TARGET_INSTANCE_NAME="target-vm-${TIMESTAMP}"
WORKER_INSTANCE_NAME="worker-vm-${TIMESTAMP}"
PROJECT_ID=""
ZONE=""

# --- Usage function ---
usage() {
  echo "Usage: $0 --project_id <PROJECT_ID> --zone <ZONE> [OPTIONS]"
  echo "emulates a boot disk swap followed by malicious IP to trigger correlated threats."
  echo
  echo "Required arguments:"
  echo "  --project_id <PROJECT_ID>  Your Google Cloud Project ID"
  echo "  --zone <ZONE>              The Google Cloud zone to create resources in (e.g., us-central1-a)"
  echo
  echo "Optional arguments:"
  echo "  --help                   Display this help message"
}

# --- Function to run gcloud commands with --quiet ---
run_gcloud() {
  echo "Running: gcloud $*"
  gcloud "$@" --quiet
}

main() {
  # --- Parse arguments ---
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --project_id)
        PROJECT_ID="$2"
        shift 2
        ;;
      --zone)
        ZONE="$2"
        shift 2
        ;;
      --help)
        usage
        exit 0
        ;;
      *)
        echo "Unknown option: $1" >&2
        usage >&2
        exit 1
        ;;
    esac
  done

  # --- Validate required arguments ---
  if [[ -z "${PROJECT_ID}" ]]; then
    echo "Error: --project_id is required." >&2
    usage >&2
    exit 1
  fi

  if [[ -z "${ZONE}" ]]; then
    echo "Error: --zone is required." >&2
    usage >&2
    exit 1
  fi

  # The boot disk name defaults to the instance name
  BOOT_DISK_NAME=$TARGET_INSTANCE_NAME

  echo "Starting script with the following settings:"
  echo "PROJECT_ID:           ${PROJECT_ID}"
  echo "ZONE:                 ${ZONE}"
  echo "TARGET_INSTANCE_NAME: ${TARGET_INSTANCE_NAME}"
  echo "WORKER_INSTANCE_NAME: ${WORKER_INSTANCE_NAME}"
  echo "BOOT_DISK_NAME:       ${BOOT_DISK_NAME}"
  echo "IMAGE_FAMILY:         ${IMAGE_FAMILY}"
  echo "IMAGE_PROJECT:        ${IMAGE_PROJECT}"
  echo "--------------------------------------------------"

  # Set context
  gcloud config set project "${PROJECT_ID}"
  gcloud config set compute/zone "${ZONE}"

  echo "Step 1: Create target VM: ${TARGET_INSTANCE_NAME}"
  run_gcloud compute instances create "${TARGET_INSTANCE_NAME}" \
    --image-family="${IMAGE_FAMILY}" \
    --image-project="${IMAGE_PROJECT}" \
    --no-address

  echo "Step 2: Create worker VM: ${WORKER_INSTANCE_NAME}"
  run_gcloud compute instances create "${WORKER_INSTANCE_NAME}" \
    --image-family="${IMAGE_FAMILY}" \
    --image-project="${IMAGE_PROJECT}" \
    --no-address

  echo "Step 3: Stop target VM: ${TARGET_INSTANCE_NAME}"
  run_gcloud compute instances stop "${TARGET_INSTANCE_NAME}"

  echo "Step 4: Detach boot disk from target VM"
  run_gcloud compute instances detach-disk "${TARGET_INSTANCE_NAME}" --disk="${BOOT_DISK_NAME}"

  echo "Step 5: Attach disk to worker VM: ${WORKER_INSTANCE_NAME}"
  run_gcloud compute instances attach-disk "${WORKER_INSTANCE_NAME}" --disk="${BOOT_DISK_NAME}"

  echo " << At this point, the disk is attached to the worker VM >>"
  echo " << Malicious modifications could theoretically be made here >>"

  echo "Step 6: Detach disk from worker VM"
  run_gcloud compute instances detach-disk "${WORKER_INSTANCE_NAME}" --disk="${BOOT_DISK_NAME}"

  echo "Step 7: Re-attach disk to target VM as boot disk"
  run_gcloud compute instances attach-disk "${TARGET_INSTANCE_NAME}" --disk="${BOOT_DISK_NAME}" --boot

  echo "Step 8: Start target VM"
  run_gcloud compute instances start "${TARGET_INSTANCE_NAME}"

  echo -n "Step 9: Wait for instance SSH to be available"
  until gcloud compute ssh "${TARGET_INSTANCE_NAME}" --command="true" 2>/dev/null; do
    echo -n "."
    sleep 2
  done
  echo

  echo "Step 10: Trigger bad IP findings"
  run_gcloud compute ssh "${TARGET_INSTANCE_NAME}" \
    --command="for i in {1..5}; do curl 34.66.147.47 > /dev/null 2>/dev/null; done;"

  echo "Step 11: Delete worker VM: ${WORKER_INSTANCE_NAME}"
  run_gcloud compute instances delete "${WORKER_INSTANCE_NAME}"

  echo "--- Testing Complete ---"
  echo "The script has completed executing the patterns to trigger a correlated"
  echo "threats issue. Check the Security Command Center Issues page."
  echo
  echo "After observing the issue, delete the target VM using:"
  echo "  gcloud compute instances delete ${TARGET_INSTANCE_NAME}"

  echo "${TARGET_INSTANCE_NAME}" > ./.lateral_movement_test_name
}

main "$@"

Machen Sie das Skript ausführbar:
```
chmod +x lateral_movement_test.sh
```
Führen Sie das Skript aus, um Ergebnisse zu generieren:
```
./lateral_movement_test.sh --project_id $PROJECT --zone $ZONE
```
Es kann bis zu einer Stunde dauern, bis das Problem mit Correlated Threats angezeigt wird.
Nachdem das Problem generiert wurde, führen Sie eine Bereinigung mit dem Befehl durch, der in der Ausgabe des Testskripts angegeben ist:
```
gcloud compute instances delete $(cat .lateral_movement_test_name) && rm -f .lateral_movement_test_name
```

Nächste Schritte

Weitere Informationen zur Funktionsweise von Correlated Threats