Protegendo seus aplicativos web do Amazon EKS com o AWS WAF

Por Elamaran Shanmugam, Patrick Vassell e Re Alvarez-Parmar

Analise os padrões de tráfego em qualquer site ou aplicativo web voltado para o público e você notará solicitações de conexão de todo o mundo. Além do tráfego pretendido, um aplicativo web típico responde a solicitações de bots, verificações de saúde e várias tentativas de burlar a segurança e obter acesso não autorizado.

Além de impactar a experiência do seu cliente, essas solicitações também podem aumentar seus gastos com a AWS. Atualmente, os aplicativos web essenciais para os negócios dependem de firewalls de aplicativos da web para bloquear o tráfego indesejado e proteger os aplicativos contra vulnerabilidades comuns. Mas muitos clientes enfrentam dificuldades com a complexidade quando se trata de implementar um firewall de aplicativo web eficaz. O AWS Web Application Firewall (AWS WAF) e o AWS Firewall Manager foram projetados para facilitar a proteção de seus aplicativos e APIs da web contra explorações comuns da web que podem interromper serviços, aumentar o uso de recursos e colocar dados em risco.

Esta postagem descreve como usar o AWS WAF e o AWS Firewall Manager para proteger cargas de trabalho baseadas na web que são executadas em um cluster do Amazon Elastic Kubernetes Services (Amazon EKS).

O AWS WAF oferece controle sobre o tipo de tráfego que chega às suas aplicações web. Ele permite monitorar solicitações HTTP (S) para aplicativos da web e protegê-los contra ataques de DDoS, bots e padrões de ataque comuns, como injeção de SQL ou scripts entre sites.

Se você não estiver familiarizado com firewalls de aplicativos web (WAF), ficará feliz em saber que não precisa ser um especialista em expressões regulares ou especialista em regras de firewall para usar o AWS WAF. Ele vem com um conjunto de regras gerenciadas pela AWS, para que você não precise escrever uma lógica de filtragem para se proteger contra vulnerabilidades comuns de aplicativos ou tráfego indesejado.

O AWS WAF se integra ao Amazon CloudFront, ao Application Load Balancer (ALB), ao Amazon API Gateway e ao AWS AppSync. Se você já usa um ALB como entrada para seus aplicativos hospedados no Kubernetes, você pode adicionar um firewall de aplicativos da web aos seus aplicativos em alguns minutos.

Clientes que operam em várias contas da AWS podem usar o AWS Organizations e o AWS Firewall Manager para controlar as regras do AWS WAF em várias contas em um único local. O AWS Firewall Manager monitora novos recursos ou contas criados para garantir que estejam em conformidade com um conjunto obrigatório de políticas de segurança. É uma prática recomendada executar clusters EKS em VPCs dedicadas, e o Firewall Manager pode garantir que suas regras de WAF sejam aplicadas em todas as contas, onde quer que seus aplicativos sejam executados.

Solução

Esta postagem demonstra como implementar um firewall de aplicativos web usando o AWS WAF para proteger aplicativos executados no EKS. Começaremos criando um cluster EKS e implantando uma amostra de carga de trabalho. O aplicativo de amostra que usaremos para este passo a passo é um aplicativo baseado na web que exporemos usando um Application Load Balancer. Em seguida, criaremos uma entrada do Kubernetes e associaremos uma lista de controle de acesso à web do AWS WAF (web ACL) a uma ALB na frente da entrada.

Pré-requisitos

Você precisará do seguinte para concluir o tutorial:

Crie um cluster EKS

Vamos começar definindo algumas variáveis de ambiente:

WAF_AWS_REGION=us-west-2 #Altere isso para corresponder à sua região 
WAF_ACCOUNT_ID=$(aws sts get-caller-identity --query 'Account' --output text)
WAF_EKS_CLUSTER_NAME=waf-eks-sample

Crie um cluster usando eksctl:

Observação: a criação do cluster pode levar aproximadamente 15 minutos.

eksctl create cluster \
 --name $WAF_EKS_CLUSTER_NAME \
 --region $WAF_AWS_REGION \
 --managed

Armazene o ID da VPC do cluster em uma variável de ambiente, pois precisaremos dele na próxima etapa:

WAF_VPC_ID=$(aws eks describe-cluster \ --name $WAF_EKS_CLUSTER_NAME \ --region $WAF_AWS_REGION \ --query 'cluster.resourcesVpcConfig.vpcId' \ --output text)

Instale o controlador do AWS Load Balancer

O controlador do AWS Load Balancer é um controlador do Kubernetes que é executado no seu cluster EKS e gerencia a configuração dos Network Load Balancers e dos Application Load Balancers em seu nome. Ele permite que você configure balanceadores de carga declarativamente da mesma forma que você manipula a configuração do seu aplicativo.

Instale o controlador do AWS Load Balancer executando estes comandos:

## Associe o provedor OIDC 
eksctl utils associate-iam-oidc-provider \
--cluster $WAF_EKS_CLUSTER_NAME \
--region $WAF_AWS_REGION \
--approve

## Baixe o documento de política do IAM
curl -o iam-policy.json https://raw.githubusercontent.com/aws-samples/containers-blog-maelstrom/main/eks-waf-blog/iam-policy.json

## Crie uma política do IAM 
WAF_LBC_IAM_POLICY=$(aws iam create-policy \ --policy-name AWSLoadBalancerControllerIAMPolicy-WAFDEMO \ --policy-document file://iam-policy.json)

## Obtenha o ARN da política do IAM 
WAF_LBC_IAM_POLICY_ARN=$(aws iam list-policies \ --query "Policies[?PolicyName=='AWSLoadBalancerControllerIAMPolicy-WAFDEMO'].Arn" \ --output text)

## Crie uma conta de serviço 
eksctl create iamserviceaccount \
--cluster=$WAF_EKS_CLUSTER_NAME \
--region $WAF_AWS_REGION \
--namespace=kube-system \
--name=aws-load-balancer-controller \
--override-existing-serviceaccounts \
--attach-policy-arn=${WAF_LBC_IAM_POLICY_ARN} \
--approve

## Adicione o repositório helm e instale o repositório helm do AWS Load Balancer Controller 
helm repo add eks https://aws.github.io/eks-charts && helm repo update
helm install aws-load-balancer-controller \
eks/aws-load-balancer-controller \
--namespace kube-system \
--set clusterName=$WAF_EKS_CLUSTER_NAME \
--set serviceAccount.create=false \
--set serviceAccount.name=aws-load-balancer-controller \
--set vpcId=$WAF_VPC_ID \
--set region=$WAF_AWS_REGION

Verifique se o controlador está instalado.

kubectl get deployment -n kube-system aws-load-balancer-controller

Implemente o aplicativo de exemplo

Usaremos um aplicativo de exemplo chamado Yelb para esta demonstração. Ele fornece uma interface de usuário baseada em Angular 2 que representará um aplicativo do mundo real para esta postagem. Aqui está uma visão de arquitetura de alto nível do Yelb: Visão de arquitetura de alto nível do Yelb:

Clone o repositório e implante o Yelb em seu cluster EKS:

git clone https://github.com/aws/aws-app-mesh-examples.git
cd aws-app-mesh-examples/walkthroughs/eks-getting-started/
kubectl apply -f infrastructure/yelb_initial_deployment.yaml

Verifique os recursos implantados no namespace yelb:

kubectl get all -n yelb

Nota: O banco de dados Postgres que o Yelb usa não está configurado para usar um volume persistente.

Exponha o Yelb usando uma entrada

Vamos criar uma entrada do Kubernetes para disponibilizar o Yelb publicamente. O controlador do AWS Load Balancer associará a entrada a um Application Load Balancer.

cat << EOF > yelb-ingress.yaml apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: yelb.app namespace: yelb annotations: alb.ingress.kubernetes.io/scheme: internet-facing alb.ingress.kubernetes.io/target-type: ip spec: ingressClassName: alb # Updated method to attach ingress class rules: - http: paths: - path: / pathType: Prefix backend: service: name: yelb-ui port: number: 80 EOF
kubectl apply -f yelb-ingress.yaml

Teste o aplicativo enviando uma solicitação usando curl ou usando um navegador da Web para navegar até o URL.

Pode levar algum tempo para que o balanceador de carga fique disponível. Use o comando abaixo para confirmar:

kubectl wait -n yelb ingress yelb.app --for=jsonpath='{.status.loadBalancer.ingress}' &&

YELB_URL=$(kubectl get ingress yelb.app -n yelb \ -o jsonpath="{.status.loadBalancer.ingress[].hostname}")

Você pode obter a URL usando a API Kubernetes e também navegar até o site inserindo o URL:

echo $YELB_URL

Adicione um firewall de aplicativo web à entrada

Agora que nosso aplicativo de exemplo está funcional, vamos adicionar um firewall de aplicativo web a ele. A primeira coisa que precisamos fazer é criar uma WAS web ACL. No AWS WAF, uma lista de controle de acesso à web ou uma ACL da web monitora solicitações HTTP (S) para um ou mais recursos da AWS. Esses recursos podem ser um Amazon API Gateway, AWS AppSync, Amazon CloudFront ou um Application Load Balancer.

Em uma ACL da Web do AWS WAF, você associa grupos de regras que definem os padrões de ataque a serem procurados nas solicitações da web e a ação a ser tomada quando uma solicitação corresponde aos padrões. Os grupos de regras são coleções reutilizáveis de regras. Você pode usar grupos de regras gerenciadas oferecidos e mantidos pelos fornecedores da AWS e do AWS Marketplace. Quando você usa regras gerenciadas, o AWS WAF atualiza automaticamente suas regras do WAF regularmente para garantir que seus aplicativos web estejam protegidos contra ameaças mais recentes. Você também pode escrever suas próprias regras e usar seus próprios grupos de regras.

Crie uma ACL web do AWS WAF:

WAF_WACL_ARN=$(aws wafv2 create-web-acl \ --name WAF-FOR-YELB \ --region $WAF_AWS_REGION \ --default-action Allow={} \ --scope REGIONAL \ --visibility-config SampledRequestsEnabled=true,CloudWatchMetricsEnabled=true,MetricName=YelbWAFAclMetrics \ --description 'WAF Web ACL for Yelb' \ --query 'Summary.ARN' \ --output text)

echo $WAF_WACL_ARN

Armazene o ID da ACL da web do AWS WAF em uma variável de ambiente, conforme necessário para atualizar a ACL da web do AWS WAF nas próximas etapas:

WAF_WAF_ID=$(aws wafv2 list-web-acls \ --region $WAF_AWS_REGION \ --scope REGIONAL \ --query "WebACLs[?Name=='WAF-for-Yelb'].Id" \ --output text)

Atualize a entrada e associe essa ACL da web do AWS WAF ao ALB que a entrada usa:

cat << EOF > yelb-ingress-waf.yaml apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: yelb.app namespace: yelb annotations: alb.ingress.kubernetes.io/scheme: internet-facing alb.ingress.kubernetes.io/target-type: ip alb.ingress.kubernetes.io/wafv2-acl-arn: ${WAF_WACL_ARN} spec: ingressClassName: alb rules: - http: paths: - path: / pathType: Prefix backend: service: name: yelb-ui port: number: 80 EOF
kubectl apply -f yelb-ingress-waf.yaml

Ao adicionar a anotação alb.ingress.kubernetes.io/wafv2-acl-arn para o ingress, o AWS WAF está inspecionando o tráfego de entrada. No entanto, ainda não está bloqueando nenhum tráfego. Antes de enviarmos uma solicitação para nosso aplicativo de exemplo usando curl, vamos esperar que o balanceador de carga esteja pronto para o tráfego

kubectl wait -n yelb ingress yelb.app --for=jsonpath='{.status.loadBalancer.ingress}'

Agora, vamos enviar tráfego para nosso aplicativo de exemplo:

curl $YELB_URL

Você deve ver uma resposta do servidor de interface do usuário do Yelb:

Habilite a filtragem de tráfego no AWS WAF

Associamos o ALB que nossa entrada do Kubernetes usa a uma ACL da web do AWS WAF. Cada solicitação tratada pelo nosso aplicativo de exemplo Yelb pods passa pelo AWS WAF para inspeção. Atualmente, a ACL da web do AWS WAF permite que todas as solicitações sejam aprovadas porque não configuramos nenhuma regra do AWS WAF. Para filtrar o tráfego potencialmente malicioso, precisamos especificar regras. Essas regras dirão ao AWS WAF como inspecionar solicitações da web e o que fazer quando encontrar uma solicitação que corresponda aos critérios de inspeção.

O AWS WAF Bot Control é um grupo de regras gerenciadas que fornece visibilidade e controle sobre o tráfego comum e generalizado de bots para aplicativos da web. O grupo de regras gerenciadas do Bot Control foi ajustado para detectar vários tipos de bots vistos na web. Ele também pode detectar solicitações geradas a partir de bibliotecas HTTP, como libcurl.

Como nossa amostra de carga de trabalho não é popular o suficiente para atrair tráfego malicioso, vamos usar o curl para gerar tráfego semelhante ao de um bot. Uma vez ativado, esperamos que os usuários que acessam nosso aplicativo a partir de um navegador da Web, como o Firefox ou o Chrome, tenham permissão para entrar, enquanto o tráfego gerado pelo curl será bloqueado.

Embora o Bot Control tenha sido otimizado para minimizar os falsos positivos, recomendamos que você implante primeiro o Bot Control no modo de contagem e revise as métricas do CloudWatch e os logs do AWS WAF para garantir que você não esteja bloqueando acidentalmente o tráfego legítimo. Você pode usar o recurso de rótulos no AWS WAF para personalizar o comportamento do Bot Control. Com base nos rótulos gerados pelo Bot Control, você pode fazer com que o AWS WAF realize uma ação alternativa, como enviar respostas personalizadas de volta ao cliente. Os clientes usam respostas personalizadas para substituir a resposta padrão, que é 403 (Proibido), para bloquear ações quando desejam enviar um status não padrão, enviar um código de página de erro estático de volta ao cliente ou redirecionar o cliente para uma URL diferente especificando um código de status de redirecionamento 3xx.

Crie um arquivo de regras:

cat << EOF > waf-rules.json  [ { "Name": "AWS-AWSManagedRulesBotControlRuleSet", "Priority": 0, "Statement": { "ManagedRuleGroupStatement": { "VendorName": "AWS", "Name": "AWSManagedRulesBotControlRuleSet" } }, "OverrideAction": { "None": {} }, "VisibilityConfig": { "SampledRequestsEnabled": true, "CloudWatchMetricsEnabled": true, "MetricName": "AWS-AWSManagedRulesBotControlRuleSet" } } ] EOF

Atualize a ACL da web do AWS WAF com a regra:

aws wafv2 update-web-acl \
--name WAF-FOR-YELB \
--scope REGIONAL \
--id $WAF_WAF_ID \
--default-action Allow={} \
--lock-token $(aws wafv2 list-web-acls \ --region $WAF_AWS_REGION \ --scope REGIONAL \ --query "WebACLs[?Name=='WAF-FOR-YELB'].LockToken" \ --output text) \
--visibility-config SampledRequestsEnabled=true,CloudWatchMetricsEnabled=true,MetricName=YelbWAFAclMetrics \
--region $WAF_AWS_REGION \
--rules file://waf-rules.json

Pressione q para sair da seção NextLockToken. Depois de esperar cerca de 10 segundos, teste a regra enviando uma solicitação:

curl $YELB_URL

Como você pode ver, o acesso ao aplicativo não está mais acessível pelo terminal.

Agora vamos abrir o mesmo URL no seu navegador abaixo e você deverá ver a interface do usuário do Yelb.

echo http://$YELB_URL

the Yelb UI dashboard

Observe que adicionamos o grupo de regras AWSManagedRulesBotControlRuleset à ACL web do AWS WAF(consulte o arquivo de configuração waf-rules.json). Esse grupo de regras contém regras para bloquear e gerenciar solicitações de bots, conforme descrito na documentação do AWS WAF. O AWS WAF bloqueia as solicitações que enviamos usando curl porque as regras de ACL da web do AWS WAF são configuradas para inspecionar e bloquear solicitações de strings de agentes de usuário que não parecem ser de um navegador da web.

Registro e monitoramento do AWS WAF

As equipes de segurança de rede exigem o registro do AWS WAF para atender às suas necessidades de conformidade e auditoria. O AWS WAF fornece registros quase em tempo real por meio do Amazon KinesisData Firehose. O AWS WAF registra cada solicitação junto com informações como data e hora, detalhes do cabeçalho e a ação da regra correspondente. Os clientes podem integrar os registros do AWS WAF com soluções de gerenciamento de eventos e informações de segurança (SIEM) ou outras ferramentas de análise de registros para depuração e análise forense. Você pode habilitar o registro de acesso no AWS WAF, salvar os registros do AWS WAF no Amazon S3 e usar o Amazon Athena para consultar os registros do WAF sem criar servidores. O AWS WAF também permite que você edite determinados campos durante o registro, o que é útil se suas solicitações contiverem informações confidenciais que não devem ser registradas.

Depois de implementar um AWS WAF, é fundamental revisar regularmente o tráfego de seus aplicativos para desenvolver uma compreensão básica de seus padrões de tráfego. As equipes de aplicativos e segurança devem analisar as métricas e dimensões do AWS WAF para garantir que as regras de ACL da web bloqueiem solicitações que possam potencialmente comprometer a segurança e a disponibilidade do aplicativo.

AWS Shield Advanced e WAF

Os assinantes do AWS Shield Advanced também podem engajar a equipe de resposta do AWS Shield durante um ataque ativo de DDoS. A equipe do AWS Shield Response ajuda você a analisar atividades suspeitas e a mitigar o problema. A mitigação geralmente envolve a atualização ou a criação de regras do AWS WAF e ACLs web do AWS WAF em sua conta.

AWS Firewall Manager

O AWS Firewall Manager permite que clientes que operam várias contas da AWS gerenciem centralmente sua ACL na web. Ele simplifica as tarefas de administração e manutenção em várias contas e recursos para uma variedade de proteções, incluindo AWS WAF, AWS Shield Advanced, grupos de segurança do Amazon VPC, AWS Network Firewall e Amazon Route 53 Resolver DNS Firewall.

Se você quiser usar o AWS Firewall Manager para centralizar o controle do AWS WAF em várias contas da AWS, você também precisará:

Organizações da AWS: sua organização deve usar o AWS Organizations para gerenciar suas contas, e todos os recursos devem estar habilitados. Para obter mais informações, consulte Criando uma organização e Habilitando todos os recursos em sua organização.
Uma conta de administrador do Firewall Manager: você deve designar uma das contas da AWS em sua organização como administradora do Firewall Manager do Firewall Manager. Isso dá permissão à conta para implantar políticas de segurança em toda a organização.
AWS Config: você deve habilitar o AWS Config para todas as contas da sua organização para que o Firewall Manager possa detectar recursos recém-criados. Para habilitar o AWS Config para todas as contas da sua organização, use o modelo Enable AWS Config dos modelos de amostra do StackSets.

Você pode associar o Firewall Manager a uma conta de gerenciamento ou a uma conta de membro que tenha as permissões apropriadas como administrador delegado. A documentação do AWS Organizations inclui mais informações sobre o uso do Firewall Manager com o AWS Organizations.

Limpeza

Use os comandos a seguir para excluir recursos criados durante esta publicação:

kubectl delete ingress yelb.app -n yelb
aws wafv2 delete-web-acl --id $WAF_WAF_ID --name  WAF-FOR-YELB --scope REGIONAL \
    --lock-token $(aws wafv2 list-web-acls \ --region $WAF_AWS_REGION \ --scope REGIONAL \ --query "WebACLs[?Name=='WAF-FOR-YELB'].LockToken" \ --output text) \
    --region $WAF_AWS_REGION
helm delete aws-load-balancer-controller -n kube-system

eksctl delete iamserviceaccount \
--cluster $WAF_EKS_CLUSTER_NAME \
--region $WAF_AWS_REGION \
--name aws-load-balancer-controller

aws iam detach-role-policy \
--policy-arn $WAF_LBC_IAM_POLICY_ARN \
--role-name $(aws iam list-entities-for-policy --policy-arn $WAF_LBC_IAM_POLICY_ARN --query 'PolicyRoles[0].RoleName' --output text)aws iam delete-policy \
--policy-arn $WAF_LBC_IAM_POLICY_ARN

kubectl patch targetgroupbinding k8s-yelb-yelbui-87f2ba1d97 -n yelb --type='json' -p='[{"op": "remove", "path": "/metadata/finalizers"}]'

kubectl patch svc yelb-ui -n yelb --type='json' -p='[{"op": "remove", "path": "/metadata/finalizers"}]'

kubectl delete ns yelb

eksctl delete cluster --name $WAF_EKS_CLUSTER_NAME --region $WAF_AWS_REGION

Conclusão

Esta publicação demonstra como proteger suas cargas de trabalho da web usando o AWS WAF. Os clientes do Amazon EKS se beneficiam das regras gerenciadas da AWS fornecidas pelo AWS WAF para adicionar um firewall de aplicativos web aos aplicativos web sem aprender a escrever regras do AWS WAF. Além disso, o AWS WAF Bot Control oferece visibilidade e controle sobre o tráfego comum e generalizado de bots que pode consumir recursos em excesso, distorcer métricas, causar tempo de inatividade ou realizar outras atividades indesejadas.

Recomendamos implementar um AWS WAF e testar sua eficácia realizando testes de penetração regularmente para identificar lacunas nas regras do AWS WAF. O whitepaper Diretrizes para a implementação do AWS WAF fornece um guia detalhado de implementação para qualquer pessoa que queira proteger aplicações web.

O blog da AWS