GSP474

Visão geral

O espelhamento de tráfego é um recurso importante na rede do Google Cloud para a análise e a segurança. Esse recurso tem funcionalidades semelhantes à de um TAP de rede ou uma sessão de SPAN em uma rede tradicional. Em resumo, o Espelhamento de pacotes captura o tráfego de rede (entrada e saída) de determinadas origens espelhadas, faz uma cópia e a encaminha para coletores.

O Espelhamento de pacotes captura todo o payload de cada pacote, por isso consome mais largura de banda. Como esse processo não se baseia em um período de amostragem, ele pode ser usado para melhorar a solução de problemas, as soluções de segurança e a análise com base em aplicativos de camadas.

O Espelhamento de pacotes depende de uma política de Espelhamento de pacotes que tem os atributos a seguir:

• Região
• Redes VPC
• Origens espelhadas
• Coletor (destino)
• Tráfego espelhado (filtro)

Veja alguns pontos importantes que também precisam ser considerados:

• Somente os tráfegos TCP, UDP e ICMP podem ser espelhados. Isso atende à maioria dos casos de uso.
• As origens espelhadas e os coletores devem estar na mesma região, mas podem estar em zonas diferentes e até mesmo em VPCs diferentes, desde que elas estejam devidamente pareadas.
• Há cobrança adicional de largura de banda, principalmente entre zonas. É possível usar filtros para limitar o tráfego que está sendo espelhado.

Um dos principais casos de uso do Espelhamento de pacotes é em soluções de Sistema de detecção de intrusões (IDS). Com algumas soluções de IDS baseadas em nuvem, é preciso executar um serviço especial em cada VM de origem ou colocar um dispositivo virtual IDS in-line entre a origem e o destino da rede. Nos dois casos, é necessário considerar aspectos importantes. Por exemplo, a solução baseada em serviço, embora totalmente distribuída, precisa de um sistema operacional convidado que ofereça suporte ao software. A solução in-line pode criar um gargalo porque todo o tráfego de rede precisa passar pelo dispositivo IDS. Com a solução in-line, também não é possível capturar o tráfego "de leste a oeste" nas VMs da mesma VPC.

O Espelhamento de pacotes do Google Cloud não requer o uso de software adicional nas VMs e é totalmente distribuído em cada uma das máquinas virtuais espelhadas. O IDS do coletor é desviado do caminho com um balanceador de carga de rede interno (ILB, na sigla em inglês) e recebe o tráfego "de norte a sul" e "de leste a oeste".

Descrição do laboratório sobre Espelhamento de pacotes

Para demonstrar como o Espelhamento de pacotes pode ser usado com um IDS, veja este exemplo com o IDS de código aberto Suricata.

• Uma única VPC com duas sub-redes, uma para origens espelhadas e outra para o coletor
• Dois servidores da Web criados com um endereço IP público
• Um servidor de coletor (IDS) criado sem IP público por motivos de segurança
• Um Cloud NAT ativado para acesso à Internet conforme necessário
• Todas as VMs criadas na mesma região e zona, por motivos de custo e simplicidade

Neste laboratório, você vai criar um ambiente do Google Cloud, definir o ILB do coletor, configurar a política de Espelhamento de pacotes, além de instalar e configurar o [Suricata] (https://suricata-ids.org/) em uma instância virtual para atuar como um IDS. Depois disso, testes de rede serão feitos para validar a configuração e o uso do Espelhamento de pacotes com o IDS de código aberto. Usaremos uma configuração bastante reduzida do Suricata e do conjunto de regras para simplificar a demonstração.

Objetivos:

• Criar um ambiente de rede do Google Cloud como mostrado no diagrama acima
• Criar duas máquinas virtuais com comandos gcloud para atuar como servidores da Web
• Criar uma única máquina virtual com comandos gcloud para atuar como IDS
• Criar um balanceador de carga interno (ILB) para atuar como um coletor para o Espelhamento de pacotes
• Instalar e configurar um IDS de código aberto (Suricata) na VM do IDS
• Analisar algumas regras básicas de alerta do IDS
• Criar uma política de Espelhamento de pacotes
• Testar o Espelhamento de pacotes gerando tráfego de rede para a sub-rede espelhada
• Testar o IDS Suricata gerando tráfego de rede para simular um evento de IDS e analisar a geração de registros do IDS

Configuração e requisitos

Antes de clicar no botão Start Lab

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é iniciado quando você clica em Começar o laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório---não se esqueça: depois de começar, não será possível pausar o laboratório.

Observação: não use seu projeto ou conta do Google Cloud neste laboratório para evitar cobranças extras na sua conta.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar o laboratório. Se for preciso pagar, você verá um pop-up para selecionar a forma de pagamento. No painel Detalhes do laboratório à esquerda, você vai encontrar o seguinte:

   • O botão Abrir console do Google Cloud
   • O tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações, se forem necessárias

2. Se você estiver usando o navegador Chrome, clique em Abrir console do Google Cloud ou clique com o botão direito do mouse e selecione Abrir link em uma janela anônima.

   O laboratório ativa os recursos e depois abre a página Fazer login em outra guia.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Se necessário, copie o Nome de usuário abaixo e cole na caixa de diálogo Fazer login.

   {{{user_0.username | "Nome de usuário"}}}

   Você também encontra o Nome de usuário no painel Detalhes do laboratório.

4. Clique em Seguinte.

5. Copie a Senha abaixo e cole na caixa de diálogo de boas-vindas.

   {{{user_0.password | "Senha"}}}

   Você também encontra a Senha no painel Detalhes do laboratório.

6. Clique em Seguinte.

   Importante: você precisa usar as credenciais fornecidas no laboratório, e não as da sua conta do Google Cloud. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

7. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do Google Cloud será aberto nesta guia.

Observação: clique em Menu de navegação no canto superior esquerdo para acessar uma lista de produtos e serviços do Google Cloud.

Ativar o Cloud Shell

O Cloud Shell é uma máquina virtual com várias ferramentas de desenvolvimento. Ele tem um diretório principal permanente de 5 GB e é executado no Google Cloud. O Cloud Shell oferece acesso de linha de comando aos recursos do Google Cloud.

1. Clique em Ativar o Cloud Shell na parte de cima do console do Google Cloud.

Depois de se conectar, vai notar que sua conta já está autenticada, e que o projeto está configurado com seu PROJECT_ID. A saída contém uma linha que declara o projeto PROJECT_ID para esta sessão:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud é a ferramenta de linha de comando do Google Cloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.

2. (Opcional) É possível listar o nome da conta ativa usando este comando:

gcloud auth list

3. Clique em Autorizar.

4. A saída será parecida com esta:

Saída:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Opcional) É possível listar o ID do projeto usando este comando:

gcloud config list project

Saída:

[core] project = <project_ID>

Exemplo de saída:

[core] project = qwiklabs-gcp-44776a13dea667a6 Observação: para conferir a documentação completa da gcloud, acesse o guia com informações gerais sobre a gcloud CLI no Google Cloud.

Tarefa 1: criar uma base de rede

Nesta seção, você criará uma VPC e duas sub-redes dentro dela. Para isso, você vai usar os comandos da CLI gcloud no Google Cloud Shell.

1. Execute o comando a seguir para criar uma rede privada virtual:

gcloud compute networks create dm-stamford \ --subnet-mode=custom

2. Adicione uma sub-rede à VPC para tráfego espelhado em :

gcloud compute networks subnets create dm-stamford-{{{project_0.default_region | REGION}}} \ --range=172.21.0.0/24 \ --network=dm-stamford \ --region={{{project_0.default_region | REGION}}}

3. Adicione uma sub-rede à VPC para o coletor em :

gcloud compute networks subnets create dm-stamford-{{{project_0.default_region | REGION}}}-ids \ --range=172.21.1.0/24 \ --network=dm-stamford \ --region={{{project_0.default_region | REGION}}}

Clique em Verificar meu progresso para conferir o objetivo.

Criar uma base de rede

Tarefa 2: criar regras de firewall e um Cloud NAT

Serão necessárias três regras de firewall para concluir este laboratório.

• A regra 1 libera a porta HTTP padrão (TCP 80) e o protocolo ICMP para as VMs de todas as origens.
• A regra 2 permite que o IDS receba todo o tráfego de todas as origens. Tenha cuidado para NÃO fornecer um IP público à VM do IDS nas próximas seções.
• A regra nº 3 permite a porta TCP 22 do intervalo de IP "Google Cloud IAP Proxy" para TODAS as VMs, possibilitando conexões via SSH às VMs pelo console do Cloud

Execute os comandos a seguir para criar as regras de firewall:

gcloud compute firewall-rules create fw-dm-stamford-allow-any-web \ --direction=INGRESS \ --priority=1000 \ --network=dm-stamford \ --action=ALLOW \ --rules=tcp:80,icmp \ --source-ranges=0.0.0.0/0 gcloud compute firewall-rules create fw-dm-stamford-ids-any-any \ --direction=INGRESS \ --priority=1000 \ --network=dm-stamford \ --action=ALLOW \ --rules=all \ --source-ranges=0.0.0.0/0 \ --target-tags=ids gcloud compute firewall-rules create fw-dm-stamford-iapproxy \ --direction=INGRESS \ --priority=1000 \ --network=dm-stamford \ --action=ALLOW \ --rules=tcp:22,icmp \ --source-ranges=35.235.240.0/20

Clique em Verificar meu progresso para conferir o objetivo.

Criar regras de firewall e um Cloud NAT

Crie um Cloud Router

• Como pré-requisito do Cloud NAT, é necessário configurar o Cloud Router na respectiva região:

gcloud compute routers create router-stamford-nat-{{{project_0.default_region | REGION}}} \ --region={{{project_0.default_region | REGION}}} \ --network=dm-stamford

Configure um Cloud NAT

• Para que as VMs tenham acesso à Internet sem um IP público, você precisa criar um Cloud NAT na respectiva região:

gcloud compute routers nats create nat-gw-dm-stamford-{{{project_0.default_region | REGION}}} \ --router=router-stamford-nat-{{{project_0.default_region | REGION}}} \ --router-region={{{project_0.default_region | REGION}}} \ --auto-allocate-nat-external-ips \ --nat-all-subnet-ip-ranges

A VM do IDS será criada sem um IP público para impedir o acesso a ela pela Internet. No entanto, o acesso à Internet será necessário para o download das atualizações e a instalação dos pacotes do Suricata.

Clique em Verificar meu progresso para conferir o objetivo.

Criar um Cloud Router e configurar um Cloud NAT

Tarefa 3: criar máquinas virtuais

Crie um modelo de instância para um servidor da Web

• Este modelo prepara um servidor Ubuntu em e instala um serviço da Web simples:

gcloud compute instance-templates create template-dm-stamford-web-{{{project_0.default_region | REGION}}} \ --region={{{project_0.default_region | REGION}}} \ --network=dm-stamford \ --subnet=dm-stamford-{{{project_0.default_region | REGION}}} \ --machine-type=e2-small \ --image=ubuntu-1604-xenial-v20200807 \ --image-project=ubuntu-os-cloud \ --tags=webserver \ --metadata=startup-script='#! /bin/bash apt-get update apt-get install apache2 -y vm_hostname="$(curl -H "Metadata-Flavor:Google" \ http://169.254.169.254/computeMetadata/v1/instance/name)" echo "Page served from: $vm_hostname" | \ tee /var/www/html/index.html systemctl restart apache2'

Crie um grupo gerenciado de instâncias para os servidores da Web

• O comando vai usar o modelo de instância da etapa anterior para criar dois servidores da Web:

gcloud compute instance-groups managed create mig-dm-stamford-web-{{{project_0.default_region | REGION}}} \ --template=template-dm-stamford-web-{{{project_0.default_region | REGION}}} \ --size=2 \ --zone={{{project_0.default_zone | "ZONE"}}}

Crie um modelo de instância para a VM do IDS

• Este modelo prepara um servidor Ubuntu em sem IP público:

gcloud compute instance-templates create template-dm-stamford-ids-{{{project_0.default_region | REGION}}} \ --region={{{project_0.default_region | REGION}}} \ --network=dm-stamford \ --no-address \ --subnet=dm-stamford-{{{project_0.default_region | REGION}}}-ids \ --image=ubuntu-1604-xenial-v20200807 \ --image-project=ubuntu-os-cloud \ --tags=ids,webserver \ --metadata=startup-script='#! /bin/bash apt-get update apt-get install apache2 -y vm_hostname="$(curl -H "Metadata-Flavor:Google" \ http://169.254.169.254/computeMetadata/v1/instance/name)" echo "Page served from: $vm_hostname" | \ tee /var/www/html/index.html systemctl restart apache2'

Crie um grupo gerenciado de instâncias para a VM do IDS

• O comando vai usar o modelo de instância da etapa anterior para criar uma VM que será configurada como seu IDS. Vamos abordar a instalação do Suricata em outra seção.

gcloud compute instance-groups managed create mig-dm-stamford-ids-{{{project_0.default_region | REGION}}} \ --template=template-dm-stamford-ids-{{{project_0.default_region | REGION}}} \ --size=1 \ --zone={{{project_0.default_zone | "ZONE"}}}

Clique em Verificar meu progresso para conferir o objetivo.

Criar máquinas virtuais

Tarefa 4: criar um balanceador de carga interno

O Espelhamento de pacotes usa um balanceador de carga interno (ILB, na sigla em inglês) para encaminhar o tráfego espelhado a um grupo de coletores. Nesse caso, o grupo contém uma única VM.

1. Crie uma verificação de integridade básica para os serviços de back-end:

gcloud compute health-checks create tcp hc-tcp-80 --port 80

2. Crie um grupo de serviços de back-end para ser usado em um ILB:

gcloud compute backend-services create be-dm-stamford-suricata-{{{project_0.default_region | REGION}}} \ --load-balancing-scheme=INTERNAL \ --health-checks=hc-tcp-80 \ --network=dm-stamford \ --protocol=TCP \ --region={{{project_0.default_region | REGION}}}

3. Acrescente o grupo gerenciado de instâncias do IDS ao grupo de serviços de back-end criado na etapa anterior:

gcloud compute backend-services add-backend be-dm-stamford-suricata-{{{project_0.default_region | REGION}}} \ --instance-group=mig-dm-stamford-ids-{{{project_0.default_region | REGION}}} \ --instance-group-zone={{{project_0.default_zone | "ZONE"}}} \ --region={{{project_0.default_region | REGION}}}

4. Crie uma regra de encaminhamento de front-end para atuar como endpoint de coleta:

gcloud compute forwarding-rules create ilb-dm-stamford-suricata-ilb-{{{project_0.default_region | REGION}}} \ --load-balancing-scheme=INTERNAL \ --backend-service be-dm-stamford-suricata-{{{project_0.default_region | REGION}}} \ --is-mirroring-collector \ --network=dm-stamford \ --region={{{project_0.default_region | REGION}}} \ --subnet=dm-stamford-{{{project_0.default_region | REGION}}}-ids \ --ip-protocol=TCP \ --ports=all Observação: o TCP está listado como protocolo, mas o tipo real de tráfego espelhado será configurado na política de espelhamento de pacotes em uma seção futura. Observe também que o flag --is-mirroring-collector, foi definido.

Clique em Verificar meu progresso para conferir o objetivo.

Criar um balanceador de carga interno

Tarefa 5: instalar o IDS de código aberto Suricata

Observação: nas próximas duas seções, você terá que usar o SSH na VM do IDS e executar os comandos no shell. Tome cuidado e não execute os comandos no Cloud Shell.

Execute SSH na VM do IDS

1. No menu de navegação do console do Cloud, acesse Compute Engine > Instâncias de VM.

2. Clique no botão SSH da VM do IDS.

Isso abre uma janela onde é possível executar comandos dentro da VM do IDS.

3. Atualize a VM do IDS:

sudo apt-get update -y

4. Instale as dependências do Suricata:

sudo apt-get install libpcre3-dbg libpcre3-dev autoconf automake libtool libpcap-dev libnet1-dev libyaml-dev zlib1g-dev libcap-ng-dev libmagic-dev libjansson-dev libjansson4 -y sudo apt-get install libnspr4-dev -y sudo apt-get install libnss3-dev -y sudo apt-get install liblz4-dev -y sudo apt install rustc cargo -y

5. Instale o Suricata:

sudo add-apt-repository ppa:oisf/suricata-stable -y sudo apt-get update -y sudo apt-get install suricata -y Observação: caso ocorra um erro durante a instalação, prossiga com a etapa de verificação a seguir.

Verifique a instalação

• Use o comando a seguir para verificar a instalação e a versão instalada do Suricata:

suricata -V

A resposta será semelhante a:

This is Suricata version 5.0.3 RELEASE

Tarefa 6: configurar e analisar o Suricata

Também é preciso executar os comandos e etapas da seção a seguir dentro do SSH da VM do IDS/Suricata.

• Pare o serviço do Suricata e faça backup do arquivo de configuração padrão:

sudo systemctl stop suricata sudo cp /etc/suricata/suricata.yaml /etc/suricata/suricata.backup

Faça o download e substitua o novo arquivo de configuração do Suricata e o de regras resumidas

O novo arquivo de configuração atualiza a interface do coletor e só envia alertas sobre um conjunto de tráfego muito pequeno, como configurado nos arquivos my.rules e suricata.yaml. Os padrões dos conjuntos de regras e alertas do Suricata são abrangentes demais e desnecessários para este laboratório.

• Execute os comandos a seguir para copiar os arquivos:

wget https://storage.googleapis.com/tech-academy-enablement/GCP-Packet-Mirroring-with-OpenSource-IDS/suricata.yaml wget https://storage.googleapis.com/tech-academy-enablement/GCP-Packet-Mirroring-with-OpenSource-IDS/my.rules sudo mkdir /etc/suricata/poc-rules sudo cp my.rules /etc/suricata/poc-rules/my.rules sudo cp suricata.yaml /etc/suricata/suricata.yaml

Inicie o serviço do Suricata

Às vezes, é preciso reiniciar o serviço. Por isso, o comando restart está incluído nesta etapa:

sudo systemctl start suricata sudo systemctl restart suricata

Analise as regras simples do Suricata para testes

As regras do Suricata foram reduzidas a apenas quatro neste laboratório. No entanto, o conjunto de regras é bem maior na instalação padrão do Suricata.

• Neste exercício, o alerta foi reduzido a uma lista simples e concisa para facilitar o teste de cada uma delas.

cat /etc/suricata/poc-rules/my.rules

A resposta deve mostrar o total de quatro regras, com a descrição de cada uma delas.

####RULES##### #UDP ALERTS alert udp $HOME_NET any -> 8.8.8.8 53 (msg:"BAD UDP DNS REQUEST"; sid:99996; rev:1;) #HTTP ALERTS alert http any any -> $HOME_NET 80 (msg:"BAD HTTP PHP REQUEST"; http.uri; content:"index.php"; sid:99997; rev:1;) #ICMP ALERTS alert icmp any any -> $HOME_NET any (msg:"BAD ICMP"; sid:99998; rev:1;) #TCP ALERTS alert tcp $HOME_NET any -> any 6667 (msg:"BAD TCP 6667 REQUEST"; sid:99999; rev:1;) Observação: os arquivos de regras padrão podem estar em /etc/suricata/rules/ ou /var/lib/suricata/rules. Na etapa 2 deste laboratório, outro local foi definido.

Tarefa 7: configurar a política de Espelhamento de pacotes

Nesta seção do laboratório, volte para o Cloud Shell

É possível configurar a política do Espelhamento de pacotes com um simples comando ou executar um assistente na GUI. No comando, você especifica os cinco atributos mencionados na seção "Descrição do laboratório sobre Espelhamento de pacotes".

• Região
• Redes VPC
• Origens espelhadas
• Coletor (destino)
• Tráfego espelhado (filtro)

Observe que o tráfego espelhado não é mencionado. Isso se deve à configuração da política para espelhar todo o tráfego, e não é necessário usar filtros. A política espelha o tráfego de entrada e saída e o encaminha ao dispositivo de IDS do Suricata, que faz parte do ILB do coletor.

• Configure a política de Espelhamento de pacotes executando o código a seguir no Cloud Shell:

gcloud compute packet-mirrorings create mirror-dm-stamford-web \ --collector-ilb=ilb-dm-stamford-suricata-ilb-{{{project_0.default_region | REGION}}} \ --network=dm-stamford \ --mirrored-subnets=dm-stamford-{{{project_0.default_region | REGION}}} \ --region={{{project_0.default_region | REGION}}}

Agora a configuração do Suricata e o Espelhamento de pacotes já devem estar prontos. As seções a seguir testarão ambos.

Clique em Verificar meu progresso para conferir o objetivo.

Configurar a política de Espelhamento de pacotes

Tarefa 8: testar o Espelhamento de pacotes

Nesta etapa, você terá que acessar o shell da VM do IDS. Use a janela do shell se ela ainda estiver aberta. Caso contrário, você vai precisar se reconectar.

Você também usará o Cloud Shell como cliente de Internet.

Reserve uns minutos para identificar o IP externo das duas VMs da Web.

No console do Cloud, no Menu de navegação, clique em Compute Engine > instâncias de VM e anote os IPs externos de cada VM da Web. Use os nomes [PUBLIC_IP_WEB1] e [PUBLIC_IP_WEB2], respectivamente.

Também é possível usar comandos gcloud no Cloud Shell para coletar as mesmas informações:

gcloud compute instances list

Volte ao shell da VM do IDS

Teste o Espelhamento de pacotes

• Execute uma captura de pacote (tcpdump) na VM do IDS/Suricata com os filtros abaixo:

sudo tcpdump -i ens4 -nn -n "(icmp or port 80) and net 172.21.0.0/24" Observação: a rede 172.21.0.0/24 é a sub-rede ESPELHADA, e a VM do IDS não faz parte dela. Se o Espelhamento de pacotes estiver configurado corretamente, a VM do IDS vai receber o tráfego espelhado dessa sub-rede.

Gere tráfego para a sub-rede "espelhada"

1. Use o terminal do Cloud Shell para dar um ping no endereço público atribuído a WEB1, substituindo [PUBLIC_IP_WEB1] pelo endereço IP público de "WEB1", que pode ser observado no console do Cloud:

sudo apt install iputils-ping ping -c 4 [PUBLIC_IP_WEB1]

O Espelhamento de pacotes precisa duplicar e encaminhar o tráfego para a VM do IDS. Isso pode ser observado na captura de pacote da Etapa 1. A resposta na VM do IDS deve ser parecida com esta, em que XXXX é o endereço IP de origem das solicitações ICMP. Na resposta do tcpdump, você deve ver o IP privado do servidor da Web. O Google Cloud traduz a rede na borda.

00:55:32.980666 IP X.X.X.X > 172.21.0.2: ICMP echo request, id 3399, seq 0, length 64 00:55:32.980801 IP 172.21.0.2 > X.X.X.X: ICMP echo reply, id 3399, seq 0, length 64 00:55:33.968920 IP X.X.X.X > 172.21.0.2: ICMP echo request, id 3399, seq 1, length 64 00:55:33.968965 IP 172.21.0.2 > X.X.X.X: ICMP echo reply, id 3399, seq 1, length 64 00:55:34.980472 IP X.X.X.X > 172.21.0.2: ICMP echo request, id 3399, seq 2, length 64 00:55:34.980521 IP 172.21.0.2 > X.X.X.X: ICMP echo reply, id 3399, seq 2, length 64 00:55:35.986354 IP X.X.X.X > 172.21.0.2: ICMP echo request, id 3399, seq 3, length 64 00:55:35.986445 IP 172.21.0.2 > X.X.X.X: ICMP echo reply, id 3399, seq 3, length 64

---

A mesma coisa vai acontecer se você der um ping no endereço público de WEB2.

2. Para fazer isso, substitua [PUBLIC_IP_WEB2] pelo endereço IP público de WEB2.

ping -c 4 [PUBLIC_IP_WEB2]

O Espelhamento de pacotes vai encaminhar o tráfego para a VM do IDS. Isso pode ser observado na captura de pacote da Etapa 1. A resposta na VM do IDS será parecida com esta: Na resposta do tcpdump, você verá o IP privado do servidor da Web. O Google Cloud traduz a rede na borda.

00:00:45.309407 IP X.X.X.X > 172.21.0.3: ICMP echo request, id 25159, seq 0, length 64 00:00:45.309736 IP 172.21.0.3 > X.X.X.X: ICMP echo reply, id 25159, seq 0, length 64 00:00:46.309406 IP X.X.X.X > 172.21.0.3: ICMP echo request, id 25159, seq 1, length 64 00:00:46.309602 IP 172.21.0.3 > X.X.X.X: ICMP echo reply, id 25159, seq 1, length 64 00:00:47.306278 IP X.X.X.X > 172.21.0.3: ICMP echo request, id 25159, seq 2, length 64 00:00:47.306406 IP 172.21.0.3 > X.X.X.X: ICMP echo reply, id 25159, seq 2, length 64 00:00:48.314506 IP X.X.X.X > 172.21.0.3: ICMP echo request, id 25159, seq 3, length 64 00:00:48.314698 IP 172.21.0.3 > X.X.X.X: ICMP echo reply, id 25159, seq 3, length 64

Para demonstrar melhor como o Espelhamento de pacotes não exibe apenas os cabeçalhos de camada 3, o teste a seguir vai mostrar um HTTP GET padrão para um dos servidores da Web, incluindo o handshake TCP inicial de três vias.

1. Abra uma nova guia no navegador e o endereço público atribuído a WEB1 com o protocolo HTTP. Se preferir, use o utilitário "curl" do Console do Cloud.

2. Substitua [PUBLIC_IP_WEB1] pelo endereço IP público de "WEB1"

http://[PUBLIC_IP_WEB1]/

O Espelhamento de pacotes vai encaminhar o tráfego para a VM do IDS. Isso pode ser observado na captura de pacote da Etapa 1.

A resposta na VM do IDS será parecida com esta:

00:00:46.761748 IP X.X.X.60835 > 172.21.0.2.80: Flags [S]... 00:00:46.763037 IP 172.21.0.2.80 > X.X.X.60835: Flags [S.], ... ack ... 00:00:46.816407 IP X.X.X.60835 > 172.21.0.2.80: Flags [.], ack ... 00:00:46.823624 IP X.X.X.60835 > 172.21.0.2.80: Flags [P.], ... HTTP: GET / HTTP/1.1 00:00:46.823832 IP 172.21.0.2.80 > X.X.X.60835: Flags [.], ack ... 00:00:46.824549 IP 172.21.0.2.80 > X.X.X.60835: Flags [P.], ... HTTP: HTTP/1.1 200 OK 00:00:46.879214 IP X.X.X.60835 > 172.21.0.2.80: Flags [.], ack ... 00:00:46.888477 IP X.X.X.60835 > 172.21.0.2.80: Flags [F.], ... 00:00:46.888662 IP 172.21.0.2.80 > X.X.X.60835: Flags [F.], ... ack... 00:00:46.943915 IP X.X.X.60835 > 172.21.0.2.80: Flags [.], ack ...

---

3. O mesmo vai acontecer se você acessar o endereço público de WEB2. Substitua [PUBLIC_IP_WEB2] pelo endereço IP público de "WEB2"

http://[PUBLIC_IP_WEB2]/

O Espelhamento de pacotes vai encaminhar o tráfego para a VM do IDS. Isso pode ser observado na captura de pacote da Etapa 1.

A resposta na VM do IDS será parecida com esta:

00:00:58.819740 IP X.X.X.X.62335 > 172.21.0.3.80: Flags [S]... 00:00:58.820027 IP 172.21.0.3.80 > X.X.X.X.62335: Flags [S.], ... ack ... 00:00:58.875301 IP X.X.X.X.62335 > 172.21.0.3.80: Flags [.], ack ... 00:00:58.875329 IP X.X.X.X.62335 > 172.21.0.3.80: Flags [P.], ... HTTP: GET / HTTP/1.1 00:00:58.875448 IP 172.21.0.3.80 > X.X.X.X.62335: Flags [.], ack ... 00:00:58.876204 IP 172.21.0.3.80 > X.X.X.X.62335: Flags [P.], ... HTTP: HTTP/1.1 200 OK 00:00:58.929015 IP X.X.X.X.62335 > 172.21.0.3.80: Flags [.], ack ... 00:00:58.929047 IP X.X.X.X.62335 > 172.21.0.3.80: Flags [F.], ... 00:00:58.929244 IP 172.21.0.3.80 > X.X.X.X.62335: Flags [F.], ... ack... 00:00:58.993844 IP X.X.X.X.62335 > 172.21.0.3.80: Flags [.], ack ...

Pressione ctrl+c na VM do IDS para sair do tcpdump.

Tarefa 9: testar a inspeção e os alertas do IDS do Suricata

A seção final deste laboratório aborda o teste da integração do Espelhamento de pacotes com o IDS de código aberto Suricata. Dê uma conferida nas quatro regras do Suricata definidas para alertas mencionadas na etapa 4 da seção "Configurar e analisar o Suricata":

####RULES##### #UDP ALERTS alert udp $HOME_NET any -> 8.8.8.8 53 (msg:"BAD UDP DNS REQUEST"; sid:99996; rev:1;) #HTTP ALERTS alert http any any -> $HOME_NET 80 (msg:"BAD HTTP PHP REQUEST"; http.uri; content:"index.php"; sid:99997; rev:1;) #ICMP ALERTS alert icmp any any -> $HOME_NET any (msg:"BAD ICMP"; sid:99998; rev:1;) #TCP ALERTS alert tcp $HOME_NET any -> any 6667 (msg:"BAD TCP 6667 REQUEST"; sid:99999; rev:1;)

Nas quatro etapas a seguir, você vai gerar o tráfego de rede para acionar cada uma dessas regras. Os alertas de cada uma delas podem ser observados no arquivo do log de eventos do Suricata.

Observação: verifique se você abriu as janelas SSH para a VM do IDS e a VM do servidor da Web. É preciso consultar as duas ao mesmo tempo para concluir esta seção.

TEST1 e TEST2 serão iniciados pelo servidor da Web para testar o tráfego de saída.

TEST3 e TEST4 serão iniciados no Cloud Shell para testar o tráfego de entrada.

TEST 1: teste a regra/o alerta de saída UDP

1. Execute o comando a seguir em um dos servidores da Web para gerar o tráfego DNS de saída:

dig @8.8.8.8 example.com

2. Agora confira o alerta no arquivo do log de eventos do Suricata na VM do IDS.

Alterne para a janela SSH da VM do IDS

3. Execute o comando a seguir na janela SSH da VM IDS:

egrep "BAD UDP DNS" /var/log/suricata/eve.json

A entrada de registro será parecida com esta:

@GCP: {"timestamp":"2020-08-14T01:23:14.903210+0000","flow_id":412864167987242,"in_iface":"ens4","event_type":"alert","src_ip":"172.21.0.2","src_port":47020,"dest_ip":"8.8.8.8","dest_port":53,"proto":"UDP","alert":{"action":"allowed","gid":1,"signature_id":99996,"rev":1,"signature":"BAD UDP DNS REQUEST","category":"","severity":3},"dns":{"query":[{"type":"query","id":17268,"rrname":"EXAMPLE.COM","rrtype":"A","tx_id":0}]},"app_proto":"dns","flow":{"pkts_toserver":1,"pkts_toclient":0,"bytes_toserver":82,"bytes_toclient":0,"start":"2020-08-19T18:23:14.903210+0000"}}

TEST 2: teste a regra/o alerta TCP de saída

1. Execute o comando a seguir em um dos servidores da Web para gerar o tráfego TCP de saída, substituindo [PUBLIC_IP_WEB2] pelo endereço IP público de WEB2:

telnet [PUBLIC_IP_WEB2] 6667

2. Pressione ctrl+c para sair.

3. Agora confira o alerta no arquivo do log de eventos do Suricata na VM do IDS.

Alterne para a janela SSH da VM do IDS

4. Execute o comando a seguir na janela de SSH da VM do IDS:

egrep "BAD TCP" /var/log/suricata/eve.json

A entrada de registro será parecida com esta:

@GCP: {"timestamp":"2020-08-14T01:27:45.058526+0000","flow_id":479376049300638,"in_iface":"ens4","event_type":"alert","src_ip":"172.21.0.2","src_port":36168,"dest_ip":"100.64.1.1","dest_port":6667,"proto":"TCP","alert":{"action":"allowed","gid":1,"signature_id":99999,"rev":1,"signature":"BAD TCP 6667 REQUEST","category":"","severity":3},"flow":{"pkts_toserver":1,"pkts_toclient":0,"bytes_toserver":74,"bytes_toclient":0,"start":"2020-08-19T18:27:45.058526+0000"}}

TEST 3: teste a regra/o alerta ICMP de entrada

1. Execute o comando a seguir no Cloud Shell para gerar o tráfego ICMP de entrada.

2. Substitua [PUBLIC_IP_WEB1] pelo endereço IP público de WEB1.

ping -c 3 [PUBLIC_IP_WEB1]

3. Agora confira o alerta no arquivo do log de eventos do Suricata na VM do IDS:

egrep "BAD ICMP" /var/log/suricata/eve.json

A entrada de registro será parecida com esta:

@GCP: {"timestamp":"2020-08-14T01:24:46.065250+0000","flow_id":1114966772874978,"in_iface":"ens4","event_type":"alert","src_ip":"X.X.X.X","dest_ip":"172.21.0.2","proto":"ICMP","icmp_type":8,"icmp_code":0,"alert":{"action":"allowed","gid":1,"signature_id":99998,"rev":1,"signature":"BAD ICMP","category":"","severity":3},"flow":{"pkts_toserver":1,"pkts_toclient":0,"bytes_toserver":98,"bytes_toclient":0,"start":"2020-08-19T18:24:46.065250+0000"}}

TEST 4: teste a regra/o alerta HTTP de entrada

No navegador da Web da sua estação de trabalho local ou no curl do Cloud Shell, procure o endereço público atribuído a WEB1 para a página index.php usando o protocolo HTTP.

1. Substitua [PUBLIC_IP_WEB1] pelo endereço IP público de WEB1.

http://[PUBLIC_IP_WEB1]/index.php

2. Agora confira o alerta no arquivo do log de eventos do Suricata na VM do IDS:

egrep "BAD HTTP" /var/log/suricata/eve.json

A entrada de registro será parecida com esta:

@GCP: {"timestamp":"2020-08-14T01:26:36.794124+0000","flow_id":1901424684045611,"in_iface":"ens4","event_type":"alert","src_ip":"X.X.X.X","src_port":61132,"dest_ip":"172.21.0.3","dest_port":80,"proto":"TCP","tx_id":0,"alert":{"action":"allowed","gid":1,"signature_id":99997,"rev":1,"signature":"BAD HTTP PHP REQUEST","category":"","severity":3},"http":{"hostname":"PUBLIC_IP_WEB1","url":"\/index.php","http_user_agent":"curl\/7.64.1","http_content_type":"text\/html","http_method":"GET","protocol":"HTTP\/1.1","status":404,"length":275},"app_proto":"http","flow":{"pkts_toserver":7,"pkts_toclient":6,"bytes_toserver":658,"bytes_toclient":1284,"start":"2020-08-19T18:26:36.660779+0000"}}

Parabéns!

Chegamos ao fim do laboratório sobre o uso do Espelhamento de pacotes do Google Cloud com o IDS de código aberto Suricata.

Próximas etapas / Saiba mais

Veja mais informações sobre o Espelhamento de pacotes em:

• Visão geral do Espelhamento de pacotes

• Como usar o Espelhamento de pacotes

Para mais informações sobre o Suricata, acesse https://suricata-ids.org/

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 18 de novembro de 2024

Laboratório testado em 6 de setembro de 2023

Copyright 2024 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.