Segurança reforçada para o tráfego web de saída: Secure Web Proxy no Google Cloud Platform

O GCP Secure Web Proxy é um serviço totalmente gerenciado que oferece uma forma segura e confiável de acessar a internet e aplicações SaaS a partir das suas redes Virtual Private Cloud (VPC). Ele ajuda as organizações a aplicar políticas de segurança, se proteger contra ameaças vindas da web e ganhar visibilidade sobre o tráfego web.

Vantagens e principais recursos do GCP Secure Web Proxy em comparação com outros serviços de proxy:

• Segurança: o serviço oferece filtragem de URL, permitindo aplicar políticas de controle de acesso por categoria de URL. Ele também inspeciona tráfego TLS, o que viabiliza políticas de segurança como detecção de malware ou filtragem de conteúdo. Além disso, integra-se ao Threat Intelligence do Google Cloud para proteger contra sites maliciosos conhecidos e ataques de phishing.
• Controle de acesso granular: as políticas do Secure Web Proxy (SWP) permitem criar regras que definem como o tráfego web de saída flui dos seus recursos do Google Cloud para a internet. As políticas podem restringir o tráfego com base em origem, destino, tipo de tráfego ou em uma combinação desses fatores.
• Visibilidade e monitoramento: o Secure Web Proxy se integra ao Cloud Logging e ao Cloud Monitoring, então fica simples coletar e analisar logs e métricas do tráfego web de saída.
• Escalabilidade e confiabilidade: o GCP Secure Web Proxy é um serviço totalmente gerenciado que escala automaticamente conforme o seu tráfego, garantindo alta disponibilidade e desempenho.
• Economia de tempo operacional: o Secure Web Proxy dispensa VMs para configurar, não exige atualizações de software para manter a segurança e oferece escalonamento elástico. Depois da configuração inicial da política, uma instância regional do Secure Web Proxy já funciona out of the box.
• Custo-benefício: o serviço segue o modelo pay-as-you-go, ou seja, você paga apenas pelos recursos usados, sem compromisso prévio.

Nesta configuração, as instâncias do Secure Web Proxy ficam na HUB VPC e os workloads ficam na Spoke VPC. Todas as requisições de saída são encaminhadas ao Secure Web Proxy via VPC peering.

Arquitetura de alto nível do exemplo Hub and Spoke

Passo 1: defina as variáveis de ambiente necessárias.

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"

Passo 2: crie a rede Hub e a sub-rede.

# 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

Passo 3: crie uma sub-rede de proxy para o Secure Web Proxy. O tamanho recomendado é /23, ou 512 endereços proxy-only, já que a conectividade do Secure Web Proxy é fornecida por um pool de endereços IP reservados para esse fim.

Esse pool aloca endereços IP exclusivos no lado de saída de cada proxy para a interação com o Cloud NAT e com destinos na rede VPC. Garanta que o intervalo do proxy não se sobreponha a outras 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

Passo 4: crie a rede Spoke e suas sub-redes.

# 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

Passo 5: apague a rota padrão de internet da Spoke VPC para que todo o tráfego de saída passe pela Hub VPC.

# 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

Passo 6: crie uma instância de teste do Compute Engine na rede 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"

Passo 7: crie o VPC peering entre as redes Hub e 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

Passo 8: o Secure Web Proxy Gateway vai gerenciar o tráfego TLS, e precisamos fornecer um certificado. É com ele que o cliente se autentica no proxy. Crie um certificado SSL e envie-o para o gerenciador de certificados.

#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

Passo 9: crie uma política do Secure Web Proxy.

O Secure Web Proxy também oferece um serviço de inspeção TLS, que permite interceptar o tráfego TLS, inspecionar a requisição criptografada e aplicar políticas de segurança. Consulte a visão geral da inspeção TLS para ver exemplos de configuração.

#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

Passo 10: crie uma instância do Secure Web Proxy Gateway usando a política criada na etapa 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

Ao provisionar uma instância do Secure Web Proxy, um gateway Cloud NAT é criado para liberar o acesso à internet. Apenas endpoints do Secure Web Proxy daquela região e rede podem usar o gateway Cloud NAT. Nenhum outro endpoint, como uma instância de máquina virtual (VM) ou um nó do Google Kubernetes Engine (GKE), tem permissão para rotear tráfego pelo gateway.

Passo 11: conecte-se via SSH à instância de teste na rede Spoke para validar as requisições de saída. Como a política do Secure Web Gateway Proxy ainda não tem regras configuradas, todo o tráfego de saída será negado por padrão.

#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 da instância de teste

Passo 12: crie regras do Secure Web Proxy para permitir e negar tráfego de saída de acordo com a arquitetura de referência.

Uma regra do Secure Web Proxy (SWP) é uma instrução que define como o proxy trata o tráfego web de saída.

O exemplo de política libera a conexão de saída com base no hostname. Consulte a linguagem CEL matcher para ver a lista completa de atributos e 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 da instância de teste

Pelos resultados acima, dá para ver que o Secure Web Proxy Gateway só permite conexões de saída para os hostnames autorizados nas regras, enquanto bloqueia conexões para os demais domínios.