Más seguridad para tu tráfico web de salida con Secure Web Proxy en Google Cloud Platform

GCP Secure Web Proxy es un servicio totalmente administrado que ofrece una manera segura y confiable de acceder a Internet y a aplicaciones SaaS desde tus redes Virtual Private Cloud (VPC). Ayuda a las organizaciones a aplicar políticas de seguridad, protegerse frente a amenazas web y obtener visibilidad sobre el tráfico web.

Ventajas y características clave de GCP Secure Web Proxy frente a otros servicios proxy:

• Seguridad: el servicio incluye filtrado de URL, lo que permite aplicar políticas de control de acceso por categorías de URL. Puede inspeccionar tráfico TLS para aplicar políticas de seguridad como detección de malware o filtrado de contenido. Además, se integra con Threat Intelligence de Google Cloud para protegerte frente a sitios maliciosos conocidos y ataques de phishing.
• Control de acceso granular: con las políticas de Secure Web Proxy (SWP) se pueden crear reglas que definen cómo fluye el tráfico web saliente desde tus recursos de Google Cloud hacia Internet. Las políticas permiten restringir el tráfico según su origen, destino, tipo o una combinación de estos factores.
• Visibilidad y monitoreo: Secure Web Proxy se integra con Cloud Logging y Cloud Monitoring, así puedes recopilar y analizar fácilmente logs y métricas del tráfico web de salida.
• Escalabilidad y confiabilidad: GCP Secure Web Proxy es un servicio totalmente administrado que escala automáticamente con tu tráfico, lo que garantiza alta disponibilidad y rendimiento.
• Ahorro de tiempo operativo: Secure Web Proxy no requiere configurar VMs ni aplicar actualizaciones de software para mantener la seguridad, y ofrece escalado elástico. Tras la configuración inicial de la política, una instancia regional de Secure Web Proxy funciona desde el primer momento.
• Costo eficiente: el servicio se cobra bajo el modelo pay-as-you-go, así que solo pagas por los recursos que usas y sin compromisos por adelantado.

En esta configuración, las instancias de Secure Web Proxy se despliegan en la VPC HUB y los workloads en la VPC Spoke. Todas las solicitudes salientes se reenvían al Secure Web Proxy a través de VPC peering.

Arquitectura de alto nivel del ejemplo Hub and Spoke

Paso 1: define las variables de entorno necesarias.

export PROJECT_ID="your-project-id"
export REGION="your-region"
export HUB_VPC="hub"
export HUB_SUBNET="hub-subnet"
export HUB_SWP_SUBNET="swp-subnet" #proxy only subnet
export SPOKE_VPC="spoke"
export SPOKE_GCE_SUBNET="spoke-gce-subnet"
export SWP_CERT_NAME="swp-certificate"
export SWP_POLICY_NAME="swp-policy"

Paso 2: crea la red y la subred Hub.

# Create a Hub custom Network
gcloud compute networks create $HUB_VPC \
   --project=$PROJECT_ID \
   --subnet-mode=custom

# Create the Hub nework subnet
gcloud compute networks subnets create $HUB_SUBNET \
   --project=$PROJECT_ID \
   --network=$HUB_VPC \
   --role="ACTIVE" \
   --purpose="PRIVATE" \
   --range=10.220.0.0/23 --region=$REGION

Paso 3: crea una subred proxy para Secure Web Proxy. El tamaño recomendado es /23, es decir, 512 direcciones proxy-only, ya que la conectividad de Secure Web Proxy se proporciona mediante un pool de direcciones IP reservadas para el servicio.

Este pool asigna direcciones IP únicas en el lado de salida de cada proxy para la interacción con Cloud NAT y los destinos dentro de la red VPC. Asegúrate de que el rango del proxy no se superponga con otras redes.

# Create proxy only subnet for SWP.
gcloud compute networks subnets create $HUB_SWP_SUBNET \
   --project=$PROJECT_ID \
   --network=$HUB_VPC \
   --role="ACTIVE" \
   --purpose="REGIONAL_MANAGED_PROXY" \
   --range=192.168.0.0/23 --region=$REGION

Paso 4: crea la red Spoke y sus subredes.

# Create a Spoke custom Network and its subnet
gcloud compute networks create $SPOKE_VPC \
   --project=$PROJECT_ID \
   --subnet-mode=custom

gcloud compute networks subnets create $SPOKE_GCE_SUBNET \
   --project=$PROJECT_ID \
     --network=$SPOKE_VPC \
   --range=10.240.0.0/23 --region=$REGION

Paso 5: elimina la ruta de Internet por defecto de la VPC Spoke; así, todo el tráfico saliente se enrutará por la VPC Hub.

# Get the Default Route internet and the delete the rule
ROUTE_NAME=$(gcloud compute routes list --filter="network: $SPOKE_VPC AND nextHopGateway:default-internet-gateway" --format="value(name)")

gcloud compute routes delete $ROUTE_NAME --quiet

Paso 6: crea una instancia de prueba de Compute Engine en la red Spoke.

# Create VM
gcloud compute instances create spoke-vm \
  --zone=${REGION}-a \
  --machine-type=e2-medium \
  --network-interface=stack-type=IPV4_ONLY,subnet=${SPOKE_GCE_SUBNET},no-address \
  --project=$PROJECT_ID

# Allow ssh via IAP
gcloud compute firewall-rules create allow-ssh-ingress \
  --project=$PROJECT_ID \
  --direction=INGRESS \
  --priority=1000 \
  --network=$SPOKE_VPC \
  --action=ALLOW \
  --rules=tcp:22 \
  --source-ranges="35.235.240.0/20"

Paso 7: crea el VPC peering entre las redes VPC Hub y Spoke.

# Hub to spoke
gcloud compute networks peerings create hub-to-spoke \
   --project=$PROJECT_ID \
   --network=$HUB_VPC --peer-network=$SPOKE_VPC \
   --auto-create-routes

# Spoke to Hub
gcloud compute networks peerings create spoke-to-hub \
   --project=$PROJECT_ID \
   --network=$SPOKE_VPC --peer-network=$HUB_VPC \
   --auto-create-routes

Paso 8: el gateway de Secure Web Proxy gestionará el tráfico TLS, por lo que hace falta proporcionar un certificado. Es el certificado con el que el cliente se autentica ante el proxy. Crea un certificado SSL y súbelo al certificate manager.

#create the certificate
openssl req -x509 -newkey rsa:2048 \
  -keyout key.pem \
  -out cert.pem -days 365 \
  -subj '/CN=demo.swp.local' -nodes -addext \
  "subjectAltName=DNS:demo.swp.local"

#upload the certificate
gcloud certificate-manager certificates create $SWP_CERT_NAME \
   --certificate-file=cert.pem \
   --private-key-file=key.pem \
   --location=$REGION

Paso 9: crea una política de Secure Web Proxy.

Secure Web Proxy también ofrece un servicio de TLS inspection que permite interceptar el tráfico TLS, inspeccionar la solicitud cifrada y aplicar políticas de seguridad. Consulta la descripción general de TLS inspection para ver configuraciones de ejemplo.

#Sample policy without enable TLS inspection.
cat << EOF > swp-policy.yaml
description: Secure Web Proxy policy
name: projects/$PROJECT_ID/locations/$REGION/gatewaySecurityPolicies/$SWP_POLICY_NAME
EOF

gcloud network-security gateway-security-policies import $SWP_POLICY_NAME \
  --source=swp-policy.yaml \
  --location=$REGION

Paso 10: crea una instancia de gateway de Secure Web Proxy con la política creada en el paso anterior.

# Create config file
cat << EOF > swp-gateway.yaml
name: projects/$PROJECT_ID/locations/REGION/gateways/swp-gateway
type: SECURE_WEB_GATEWAY
ports: [443]
certificateUrls: ["projects/$PROJECT_ID/locations/$REGION/certificates/$SWP_CERT_NAME"]
gatewaySecurityPolicy: projects/$PROJECT_ID/locations/$REGION/gatewaySecurityPolicies/$SWP_POLICY_NAME
network: projects/$PROJECT_ID/global/networks/$HUB_VPC
subnetwork: projects/$PROJECT_ID/regions/$REGION/subnetworks/$HUB_SUBNET
scope: basic-scope
EOF

gcloud network-services gateways import swp-gateway-instance \
    --source=swp-gateway.yaml \
    --location=$REGION

Al aprovisionar una instancia de Secure Web Proxy se crea un gateway de Cloud NAT que habilita el acceso a Internet. Solo los endpoints de Secure Web Proxy de esa misma región y red pueden usar dicho gateway de Cloud NAT. Ningún otro endpoint, como una instancia de máquina virtual (VM) o un nodo de Google Kubernetes Engine (GKE), puede enrutar tráfico a través de él.

Paso 11: conéctate por SSH a la instancia de prueba en la red Spoke para validar las solicitudes de salida. Como la política del Secure Web Gateway Proxy aún no tiene reglas, todo el tráfico saliente se denegará por defecto.

#sample commands
#replace $SWP_HOST_IP with the IP address of the SWP Gateway IP
$export https_proxy=https://$SWP_HOST_IP
$curl -s -I --proxy-insecure https://www.example.com

Resultados desde la instancia de prueba

Paso 12: crea reglas de Secure Web Proxy para permitir y denegar tráfico saliente conforme a la arquitectura de referencia.

Una regla de Secure Web Proxy (SWP) es una declaración que define cómo el proxy maneja el tráfico web saliente.

La política de ejemplo permite la conexión saliente a partir del hostname. Consulta el lenguaje de matchers CEL para ver la lista completa de atributos y operadores.

#allow www.example.com,The rule with the lowest numeric value assigned has the highest logical priority and is evaluated prior to rules with lower logical priorities.
cat << EOF > allow-example-com.yaml
name: projects/$PROJECT_ID/locations/$REGION/gatewaySecurityPolicies/$SWP_POLICY_NAME/rules/allow-example-com
description: Allow example.com
enabled: true
priority: 1000
basicProfile: ALLOW
sessionMatcher: host() == 'www.example.com'
EOF

gcloud network-security gateway-security-policies rules import allow-example-com \
    --source=allow-example-com.yaml \
    --location=$REGION \
    --gateway-security-policy=$SWP_POLICY_NAME

#allow www.doit.com
cat << EOF > allow-doit-com.yaml
name: projects/$PROJECT_ID/locations/$REGION/gatewaySecurityPolicies/$SWP_POLICY_NAME/rules/allow-example-com
description: Allow example.com
enabled: true
priority: 999
basicProfile: ALLOW
sessionMatcher: host() == 'www.doit.com'
EOF

gcloud network-security gateway-security-policies rules import allow-doit-com \
    --source=allow-doit-com.yaml \
    --location=$REGION \
    --gateway-security-policy=$SWP_POLICY_NAME

Resultados desde la instancia de prueba

En los resultados anteriores se observa que el gateway de Secure Web Proxy solo permite las conexiones salientes hacia los hostnames autorizados en las reglas, mientras que las conexiones a otros dominios quedan bloqueadas.