GSP474

Descripción general

La duplicación de tráfico es una función clave en las redes de Google Cloud para la seguridad y el análisis de redes. Su funcionalidad es similar a la de una conexión de red o a una sesión de intervalo en las redes tradicionales. En resumen, Duplicación de paquetes captura el tráfico de red (de entrada y salida) de determinadas "fuentes duplicadas", lo copia y lo reenvía a "colectores".

Es importante tener en cuenta que la duplicación de paquetes captura la carga útil completa de cada paquete y, por lo tanto, consume ancho de banda adicional. Como no se basa en ningún período de muestreo, se puede utilizar para mejorar la resolución de problemas, las soluciones de seguridad y el análisis basado en aplicaciones de capas superiores.

Se establece sobre la base de una "política de duplicación de paquetes", que contiene los siguientes atributos:

• Región
• Redes de VPC
• Fuentes duplicadas
• Colector (destino)
• Tráfico duplicado (filtro)

Estos son algunos puntos clave que también se deben considerar:

• Solo es posible duplicar el tráfico de TCP, ICMP y UDP. No obstante, esto debería satisfacer la mayoría de los casos de uso.
• Las "fuentes duplicadas" y los "colectores" deben estar en la MISMA región, pero pueden estar en diferentes zonas y hasta distintas VPC, siempre que estas últimas intercambien tráfico de forma correcta.
• Se aplican cargos adicionales de ancho de banda, especialmente entre zonas. Para limitar el tráfico que se duplica, se pueden utilizar filtros.

Un caso de uso primordial para la duplicación de paquetes es utilizarla en una solución de Sistema de Detección de Intrusiones (IDS). Algunas soluciones de IDS basadas en la nube requieren que se ejecute un servicio especial en cada VM de origen o se coloque un dispositivo virtual IDS en línea entre la fuente de red y el destino. Ambas soluciones tienen implicaciones significativas. Por ejemplo, la solución basada en servicios, aunque esté completamente distribuida, requiere que el sistema operativo invitado admita el software. La solución en línea puede crear un cuello de botella en la red, ya que todo el tráfico se debe canalizar a través del dispositivo IDS. Esta última solución tampoco podrá capturar el tráfico de "este a oeste" dentro de las VMs en la misma VPC.

La duplicación de paquetes de Google Cloud no requiere ningún software adicional en las VMs y está completamente distribuida en cada una de las máquinas virtuales duplicadas. El IDS de "colector" se ubica fuera de la ruta mediante un balanceador de cargas de red interno (ILB) y recibe tráfico de "norte a sur" y de "este a oeste".

Descripción del lab de duplicación de paquetes

Para demostrar cómo se puede utilizar la duplicación de paquetes con un IDS, considera este ejemplo en el que se usa el IDS de código abierto Suricata.

• Una sola VPC con 2 subredes, una para fuentes duplicadas y otra para el colector
• 2 servidores web creados con una dirección IP pública
• 1 servidor de colector (IDS) creado SIN IP pública por motivos de seguridad
• Cloud NAT habilitado para acceder a Internet según sea necesario
• Todas las VMs creadas en la misma región y zona por motivos de simplicidad y costos

En este lab, crearás un entorno de Google Cloud, configurarás el ILB de “colector” y la política de duplicación de paquetes, e instalarás y configurarás [Suricata] (https://suricata-ids.org/) en una instancia virtual para que actúe como un IDS. Una vez completadas estas acciones, se realizarán pruebas de red para validar la configuración y el uso de la duplicación de paquetes con el IDS de código abierto. Se utilizarán una configuración y un conjunto de reglas básicos de Suricata para simplificar la demostración.

Objetivos:

• Compilar un entorno de Herramientas de redes de Google Cloud como se muestra en el diagrama anterior
• Crear 2 máquinas virtuales con los comandos de gcloud para que actúen como servidores web
• Crear una sola máquina virtual con los comandos de gcloud para que actúe como IDS
• Crear un balanceador de cargas interno (ILB) para que actúe como "colector" en la duplicación de paquetes
• Instalar y configurar un IDS de código abierto (Suricata) en la VM de IDS
• Revisar algunas reglas básicas de alertas del IDS
• Crear una política de duplicación de paquetes
• Probar la duplicación de paquetes generando tráfico de red a la subred "duplicada"
• Probar el IDS de Suricata mediante la generación de tráfico de red para simular un evento IDS y revisar los respectivos registros

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs cuentan con un temporizador que no se puede pausar. El temporizador, que comienza a funcionar cuando haces clic en Comenzar lab, indica por cuánto tiempo tendrás a tu disposición los recursos de Google Cloud.

Este lab práctico te permitirá realizar las actividades correspondientes en un entorno de nube real, no en uno de simulación o demostración. Para ello, se te proporcionan credenciales temporales nuevas que utilizarás para acceder a Google Cloud durante todo el lab.

Para completar este lab, necesitarás lo siguiente:

• Acceso a un navegador de Internet estándar. Se recomienda el navegador Chrome.

Nota: Usa una ventana del navegador privada o de incógnito (opción recomendada) para ejecutar el lab. Así evitarás conflictos entre tu cuenta personal y la cuenta de estudiante, lo que podría generar cargos adicionales en tu cuenta personal.

• Tiempo para completar el lab (recuerda que, una vez que comienzas un lab, no puedes pausarlo).

Nota: Usa solo la cuenta de estudiante para este lab. Si usas otra cuenta de Google Cloud, es posible que se apliquen cargos a esa cuenta.

Cómo iniciar tu lab y acceder a la consola de Google Cloud

1. Haz clic en el botón Comenzar lab. Si debes pagar por el lab, se abrirá un diálogo para que selecciones la forma de pago. A la izquierda, se encuentra el panel Detalles del lab, que tiene estos elementos:

   • El botón para abrir la consola de Google Cloud
   • El tiempo restante
   • Las credenciales temporales que debes usar para el lab
   • Otra información para completar el lab, si es necesaria

2. Haz clic en Abrir la consola de Google Cloud (o haz clic con el botón derecho y selecciona Abrir el vínculo en una ventana de incógnito si ejecutas el navegador Chrome).

   El lab inicia recursos y abre otra pestaña en la que se muestra la página de acceso.

   Sugerencia: Ordena las pestañas en ventanas separadas, una junto a la otra.

   Nota: Si ves el diálogo Elegir una cuenta, haz clic en Usar otra cuenta.

3. De ser necesario, copia el nombre de usuario a continuación y pégalo en el diálogo Acceder.

   {{{user_0.username | "Username"}}}

   También puedes encontrar el nombre de usuario en el panel Detalles del lab.

4. Haz clic en Siguiente.

5. Copia la contraseña que aparece a continuación y pégala en el diálogo Te damos la bienvenida.

   {{{user_0.password | "Password"}}}

   También puedes encontrar la contraseña en el panel Detalles del lab.

6. Haz clic en Siguiente.

   Importante: Debes usar las credenciales que te proporciona el lab. No uses las credenciales de tu cuenta de Google Cloud. Nota: Usar tu propia cuenta de Google Cloud para este lab podría generar cargos adicionales.

7. Haz clic para avanzar por las páginas siguientes:

   • Acepta los Términos y Condiciones.
   • No agregues opciones de recuperación o autenticación de dos factores (esta es una cuenta temporal).
   • No te registres para obtener pruebas gratuitas.

Después de un momento, se abrirá la consola de Google Cloud en esta pestaña.

Nota: Para acceder a los productos y servicios de Google Cloud, haz clic en el menú de navegación o escribe el nombre del servicio o producto en el campo Buscar.

Activa Cloud Shell

Cloud Shell es una máquina virtual que cuenta con herramientas para desarrolladores. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud. Cloud Shell proporciona acceso de línea de comandos a tus recursos de Google Cloud.

1. Haz clic en Activar Cloud Shell en la parte superior de la consola de Google Cloud.

2. Haz clic para avanzar por las siguientes ventanas:

   • Continúa en la ventana de información de Cloud Shell.
   • Autoriza a Cloud Shell para que use tus credenciales para realizar llamadas a la API de Google Cloud.

Cuando te conectes, habrás completado la autenticación, y el proyecto estará configurado con tu Project_ID, . El resultado contiene una línea que declara el Project_ID para esta sesión:

Your Cloud Platform project in this session is set to {{{project_0.project_id | "PROJECT_ID"}}}

gcloud es la herramienta de línea de comandos de Google Cloud. Viene preinstalada en Cloud Shell y es compatible con la función de autocompletado con tabulador.

3. Puedes solicitar el nombre de la cuenta activa con este comando (opcional):

gcloud auth list

4. Haz clic en Autorizar.

Resultado:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} To set the active account, run: $ gcloud config set account `ACCOUNT`

5. Puedes solicitar el ID del proyecto con este comando (opcional):

gcloud config list project

Resultado:

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Nota: Para obtener toda la documentación de gcloud, en Google Cloud, consulta la guía con la descripción general de gcloud CLI.

Tarea 1. Crea un entorno de redes

En esta sección, crearás una VPC y, luego, 2 subredes dentro de ella. Todo esto se realizará con los comandos de la CLI de gcloud dentro de Google Cloud Shell.

1. Ejecuta el siguiente comando para crear una red privada virtual:

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

2. Agrega una subred a la VPC para el tráfico duplicado en :

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. Agrega una subred a la VPC para el colector en :

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

Haz clic en Revisar mi progreso para verificar el objetivo.

Crear un entorno de redes

Tarea 2. Crea reglas de firewall y Cloud NAT

Deberás crear un total de tres reglas de firewall para completar este lab.

• La regla 1 habilita el puerto HTTP estándar (TCP 80) y el protocolo ICMP a todas las VMs de todas las fuentes.
• La regla 2 habilita al IDS para recibir TODO el tráfico de TODAS las fuentes. Ten cuidado de NO asignar a la VM de IDS una IP pública en las secciones posteriores.
• La regla 3 habilita el rango de puerto TCP 22 de la “IAP de Google Cloud” para todas las VMs, lo que te permite establecer una conexión SSH a través de la consola de Cloud.

Ejecuta los siguientes comandos para crear las reglas 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

Haz clic en Revisar mi progreso para verificar el objetivo.

Crea reglas de firewall de Google Cloud y Cloud NAT

Crea un Cloud Router

• Como requisito previo para Cloud NAT, primero se debe configurar un Cloud Router en la región correspondiente:

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

Configura una puerta de enlace de Cloud NAT

• Para proporcionar acceso a Internet a las VMs sin una IP pública, se debe crear una puerta de enlace de Cloud NAT en la región correspondiente:

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

La VM de IDS se creará sin una IP pública para garantizar que no se pueda acceder a ella desde Internet. Sin embargo, necesitará acceso a Internet para descargar actualizaciones e instalar paquetes de Suricata.

Haz clic en Revisar mi progreso para verificar el objetivo.

Crear un Cloud Router y configurar una puerta de enlace de Cloud NAT

Tarea 3. Crea máquinas virtuales

Crea una plantilla de instancias para un servidor web

• Esta plantilla prepara un servidor Ubuntu en además de instalar un servicio web sencillo:

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'

Crea un grupo de instancias administrado para los servidores web

• Este comando utiliza la plantilla de instancias del paso anterior para crear 2 servidores 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"}}}

Crea una plantilla de instancias para la VM de IDS

• Esta plantilla prepara un servidor Ubuntu en sin contar con una IP pública:

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'

Crea un grupo de instancias administrado para la VM de IDS

• Este comando utiliza la Plantilla de instancias del paso anterior para crear 1 VM que se configurará como tu IDS. La instalación de Suricata se abordará en una sección posterior.

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

Haz clic en Revisar mi progreso para verificar el objetivo.

Crear máquinas virtuales

Tarea 4. Crea un balanceador de cargas interno

La duplicación de paquetes utiliza un balanceador de cargas interno (ILB) para reenviar el tráfico duplicado a un grupo de colectores. En este caso, el grupo de colectores contiene una sola VM.

1. Crea una verificación de estado básica para los servicios de backend:

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

2. Crea un grupo de servicios de backend para utilizarlo en un 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. Agrega el grupo de instancias administrado de IDS que se creó al grupo de servicios de backend del paso 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. Crea una regla de reenvío de frontend para que actúe como el extremo de recopilación:

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 Nota: A pesar de que TCP se muestra como el protocolo, el verdadero tipo de tráfico duplicado se configurará en la Política de Duplicación de Paquetes que está en una sección posterior. Además, ten en cuenta que se estableció la marca--is-mirroring-collector,.

Haz clic en Revisar mi progreso para verificar el objetivo.

Crear un balanceador de cargas interno

Tarea 5. Instala el IDS de código abierto Suricata

Nota: En las 2 secciones a continuación, te conectarás a la VM de IDS con una conexión SSH y ejecutarás los comandos en su shell. Ten cuidado de no ejecutar los comandos en Cloud Shell.

Establece una conexión SSH a la VM de IDS

1. En el menú de navegación de la consola de Cloud, navega a Compute Engine > Instancias de VM.

2. Haz clic en el botón SSH de la VM de IDS.

Se abrirá una ventana nueva que te permitirá ejecutar comandos dentro de la VM de IDS.

3. Actualiza la VM de IDS:

sudo apt-get update -y

4. Instala las dependencias de 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. Instala Suricata:

sudo add-apt-repository ppa:oisf/suricata-stable -y sudo apt-get update -y sudo apt-get install suricata -y Nota: Si recibes un error durante la instalación, haz el siguiente paso de verificación.

Verifica la instalación

• Ejecuta el siguiente comando para verificar la instalación y la versión de Suricata:

suricata -V

El resultado debería ser similar al siguiente:

Este es el lanzamiento de la versión 5.0.3 de Suricata

Tarea 6. Configura y revisa Suricata

Los comandos y los pasos de la siguiente sección también se deben realizar en la ventana de SSH de la VM de Suricata o IDS.

• Detén el servicio de Suricata y crea una copia de seguridad del archivo de configuración predeterminado:

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

Descarga y reemplaza el nuevo archivo de configuración de Suricata y el archivo abreviado de reglas

El nuevo archivo de configuración actualiza la interfaz del colector y solo alerta sobre un conjunto de tráfico muy pequeño, como se configuró en los archivos my.rules y suricata.yaml. Las configuraciones predeterminadas para los conjuntos de reglas y alertas de Suricata son bastante extensas y superfluas para este lab.

• Ejecuta los siguientes comandos para copiar los archivos.

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

Inicia el servicio de Suricata

A veces, se debe reiniciar el servicio. En caso de que esto suceda, se incluye el comando restart en este paso:

sudo systemctl start suricata sudo systemctl restart suricata

Revisa reglas simples de Suricata para probarlas

Para este lab, el conjunto de reglas de Suricata se redujo a 4. Sin embargo, la instalación predeterminada de Suricata consta de un extenso conjunto de reglas.

• Condensar las alertas en una lista breve y sencilla es una mejor opción para este ejercicio del lab, para que se pueda probar cada una con facilidad.

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

El resultado debería mostrar un total de 4 reglas con sus respectivas descripciones.

####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;) Nota: Los archivos con reglas estándares suelen estar ubicados en /etc/suricata/rules/ o /var/lib/suricata/rules. Para este lab, se reconfiguraron en una ubicación diferente en el paso 2.

Tarea 7. Configura la política de duplicación de paquetes

Para esta sección del lab, regresa a Cloud Shell.

La configuración de la política de duplicación de paquetes se puede completar en un comando simple (o mediante un "asistente" en la GUI). En este comando, se especifican los 5 atributos mencionados en la sección en la que se describe la duplicación de paquetes.

• Región
• Redes de VPC
• Fuentes duplicadas
• Colector (destino)
• Tráfico duplicado (filtro)

Puedes notar que no se menciona el "tráfico duplicado". Esto se debe a que la política se configurará para duplicar "TODO" el tráfico, por lo que no se necesita realizar ningún filtro. La política duplicará el tráfico de entrada y salida, y lo reenviará al dispositivo IDS de Suricata, que es parte del ILB del colector.

• Para configurar la política de duplicación de paquetes, ejecuta lo siguiente en 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}}}

En este punto, la configuración de la duplicación de paquetes y Suricata debería estar completa. En las siguientes secciones, se probarán ambas.

Haz clic en Revisar mi progreso para verificar el objetivo.

Configurar la política de duplicación de paquetes

Tarea 8. Prueba la duplicación de paquetes

En esta sección, deberás acceder al shell de la VM de IDS. Si la ventana de la shell aún está abierta, utilízala. Si se cerró, vuelve a conectarte.

También utilizarás Cloud Shell para que actúe como “cliente de Internet”.

Tómate unos minutos para encontrar la IP externa de las dos VMs WEB.

Desde el Menú de navegación de la consola de Cloud, haz clic en Compute Engine > Instancias de VM y anota las IPs externas de las dos VMs WEB. Estas se llaman [PUBLIC_IP_WEB1] y [PUBLIC_IP_WEB2], respectivamente.

También puedes recopilar la misma información mediante los comandos de gcloud desde Cloud Shell:

gcloud compute instances list

Regresa a la shell de la VM de IDS

Prueba la duplicación de paquetes

• Ejecuta una captura de paquetes (tcpdump) en la VM de Suricata o IDS con los siguientes filtros:

sudo tcpdump -i ens4 -nn -n "(icmp or port 80) and net 172.21.0.0/24" Nota: La red 172.21.0.0/24 es la subred DUPLICADA; y la VM de IDS no pertenece a esa subred. Si la duplicación de paquetes se configuró de forma correcta, la VM de IDS debería recibir tráfico duplicado para esa subred.

Genera tráfico a la subred “duplicada”

1. Mediante la terminal de Cloud Shell, haz ping a la dirección pública asignada a “WEB1”. Para ello, reemplaza [PUBLIC_IP_WEB1] por la dirección IP pública correspondiente, la cual se puede ver en la consola de Cloud:

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

La duplicación de paquetes debería hacer una copia exacta de ese tráfico y reenviarlo a la VM de IDS, y tú deberías poder consultarlo en la captura de paquetes del paso 1. El resultado en la VM de IDS debería ser similar al siguiente, en el que X.X.X.X es la dirección IP de origen de las solicitudes de ICMP. En el resultado tcpdump, deberías observar la IP privada del servidor web. Google Cloud realiza la traducción de red en el perímetro.

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

---

Lo mismo debería suceder si haces ping a la dirección pública de WEB2.

2. Haz ping a la dirección pública asignada a WEB2. Para ello, reemplaza [PUBLIC_IP_WEB2] por la dirección IP pública correspondiente.

ping -c 4 [PUBLIC_IP_WEB2]

La duplicación de paquetes debería reenviar ese tráfico a la VM de IDS, y tú deberías poder consultarlo en la captura de paquetes del paso 1. El resultado en la VM de IDS debería ser similar al siguiente: Ten en cuenta que deberías observar la IP privada del servidor web en el resultado de tcpdump. Google Cloud realiza la traducción de red en el perímetro.

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 demostrar mejor que la duplicación de paquetes muestra más que solo los encabezados de capa 3, la siguiente prueba mostrará una solicitud HTTP GET estándar a uno de los servidores web, incluido el protocolo de enlace inicial de TCP de 3 vías.

1. Abre una pestaña nueva en tu navegador y luego la dirección pública asignada a WEB1 con el protocolo HTTP. También puedes abrirla mediante la utilidad “curl” de la consola de Cloud si así lo prefieres.

2. Reemplaza [PUBLIC_IP_WEB1] por la dirección IP pública de “WEB1”:

http://[PUBLIC_IP_WEB1]/

La duplicación de paquetes debería reenviar ese tráfico a la VM de IDS, y tú deberías poder consultarlo en la captura de paquetes del paso 1.

El resultado en la VM de IDS debería ser similar al siguiente:

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. Lo mismo debería suceder si navegas a la dirección pública de WEB2. Reemplaza [PUBLIC_IP_WEB2] por la dirección IP pública de "WEB2":

http://[PUBLIC_IP_WEB2]/

La duplicación de paquetes debería reenviar ese tráfico a la VM de IDS, y tú deberías poder consultarlo en la captura de paquetes del paso 1.

El resultado en la VM de IDS debería ser similar al siguiente:

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 ...

Ingresa Ctrl + c en la VM de IDS para salir de tcpdump.

Tarea 9. Prueba las alertas y la inspección de IDS de Suricata

En la última sección de este lab, se probará la integración de la duplicación de paquetes con el IDS de código abierto Suricata. Tómate un minuto y revisa las 4 reglas de Suricata que se establecieron para crear alertas en el paso 4, en la sección “Configura y revisa 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;)

En los siguientes 4 pasos, generarás tráfico de red que activará cada una de estas reglas. Las alertas para cada una de ellas se deberían mostrar en el archivo de registro de eventos de Suricata.

Nota: Asegúrate de haber abierto ventanas de SSH para la VM de IDS y una VM de servidor web. Deberás visualizar AMBAS de forma simultánea para completar esta sección.

TEST1 y TEST2 se iniciarán desde el SERVIDOR WEB y examinarán el tráfico de salida.

TEST3 y TEST4 se iniciarán en Cloud Shell y examinarán el tráfico de entrada.

TEST 1: Examina la regla o la alerta UDP de salida

1. Ejecuta el siguiente comando desde uno de los servidores web para generar tráfico de DNS de salida:

dig @8.8.8.8 example.com

2. Ahora observa la alerta en el archivo de registro de eventos de Suricata en la VM de IDS.

Cambia a la ventana de SSH para la VM de IDS

3. Ejecuta el siguiente comando en la ventana de SSH para la VM de IDS:

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

La entrada de registro debería ser similar a la siguiente:

@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: Examina la regla o la alerta de “TCP” de salida

1. Ejecuta el siguiente comando desde uno de los servidores web para generar tráfico de TCP de salida. Para ello, reemplaza [PUBLIC_IP_WEB2] por la dirección IP pública de "WEB2":

telnet [PUBLIC_IP_WEB2] 6667

2. Ingresa Ctrl + c para salir.

3. Ahora observa la alerta en el archivo de registro de eventos de Suricata en la VM de IDS.

Cambia a la ventana de SSH para la VM de IDS

4. Ejecuta el siguiente comando desde la ventana de SSH de la VM de IDS:

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

La entrada de registro debería ser similar a la siguiente:

@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: Examina la regla o la alerta de “ICMP” de entrada

1. Ejecuta el siguiente comando desde Cloud Shell para generar tráfico de ICMP de entrada.

2. Reemplaza [PUBLIC_IP_WEB1] por la dirección IP pública de “WEB1”.

ping -c 3 [PUBLIC_IP_WEB1]

3. Ahora observa la alerta en el archivo de registro de eventos de Suricata en la VM de IDS:

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

La entrada de registro debería ser similar a la siguiente:

@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: Examina la regla o la alerta de “HTTP” de entrada

Usa el navegador web de tu estación de trabajo local o curl en Cloud Shell para navegar con el protocolo HTTP por la dirección pública asignada a WEB1, la cual es la página de index.php.

1. Reemplaza [PUBLIC_IP_WEB1] por la dirección IP pública de “WEB1”.

http://[PUBLIC_IP_WEB1]/index.php

2. Ahora observa la alerta en el archivo de registro de eventos de Suricata en la VM de IDS:

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

La entrada de registro debería ser similar a la siguiente:

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

¡Felicitaciones!

De esta manera, se completa el lab sobre el uso de la duplicación de paquetes de Google Cloud con el IDS de código abierto Suricata.

Próximos pasos/Más información

Para obtener información adicional sobre la duplicación de paquetes, consulta la siguiente documentación:

• Descripción general de la duplicación de paquetes

• Usa la duplicación de paquetes

Para obtener más información sobre Suricata, consulta https://suricata-ids.org/

Capacitación y certificación de Google Cloud

Recibe la formación que necesitas para aprovechar al máximo las tecnologías de Google Cloud. Nuestras clases incluyen habilidades técnicas y recomendaciones para ayudarte a avanzar rápidamente y a seguir aprendiendo. Para que puedas realizar nuestros cursos cuando más te convenga, ofrecemos distintos tipos de capacitación de nivel básico a avanzado: a pedido, presenciales y virtuales. Las certificaciones te ayudan a validar y demostrar tus habilidades y tu conocimiento técnico respecto a las tecnologías de Google Cloud.

Actualización más reciente del manual: 18 de noviembre de 2024

Prueba más reciente del lab: 6 de septiembre de 2023

Copyright 2025 Google LLC. All rights reserved. Google y el logotipo de Google son marcas de Google LLC. Los demás nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que estén asociados.