Lab 47 — WAF e Shield: barrar antes de custar computação

{
  "timestamp": 1754582431618,
  "webaclId": "arn:aws:wafv2:us-east-1:111122223333:global/webacl/ffv-lab-borda/...",
  "action": "BLOCK",
  "terminatingRuleId": "limite-por-ip",
  "terminatingRuleType": "RATE_BASED",
  "httpRequest": {
    "clientIp": "203.0.113.44",
    "uri": "/api/login",
    "httpMethod": "POST"
  },
  "rateBasedRuleList": [
    { "rateBasedRuleId": "limite-por-ip", "limitValue": 2000 }
  ]
}

# waf.tf — o WebACL, e por que ele vive na mesma regiao que o certificado do L05

# O escopo CLOUDFRONT exige que o WebACL e tudo que ele referencia — grupo de
# regra, conjunto de IP — sejam criados em us-east-1, independente de onde os
# visitantes estao ou de onde a origem roda. E a MESMA exigencia que o
# certificado ACM do L05 tem, e reaproveitamos o mesmo alias de provider.
resource "aws_wafv2_web_acl" "borda" {
  provider    = aws.borda # o alias us-east-1 que o L05 ja declara
  name        = "${var.projeto}-borda"
  description = "Regras gerenciadas + taxa por IP, na frente da distribuicao do L05"
  scope       = "CLOUDFRONT"

  # Sem correspondencia terminante em nenhuma regra, a requisicao passa. E a
  # rede de seguranca para trafego que nenhuma regra reconhece.
  default_action {
    allow {}
  }

  # ── Regra 1: padroes conhecidos de ataque, mantidos pela AWS ───────────────
  # Bloqueia por CONTEUDO da requisicao, independente de volume. Prioridade
  # menor = avaliada primeiro.
  rule {
    name     = "regras-gerenciadas-core"
    priority = 0

    override_action {
      none {} # usa a acao que cada regra do grupo ja define
    }

    statement {
      managed_rule_group_statement {
        name        = "AWSManagedRulesCommonRuleSet"
        vendor_name = "AWS"
      }
    }

    visibility_config {
      cloudwatch_metrics_enabled = true
      metric_name                = "regrasGerenciadasCore"
      sampled_requests_enabled   = true
    }
  }

  rule {
    name     = "regras-gerenciadas-entradas-invalidas"
    priority = 1

    override_action {
      none {}
    }

    statement {
      managed_rule_group_statement {
        name        = "AWSManagedRulesKnownBadInputsRuleSet"
        vendor_name = "AWS"
      }
    }

    visibility_config {
      cloudwatch_metrics_enabled = true
      metric_name                = "regrasGerenciadasEntradasInvalidas"
      sampled_requests_enabled   = true
    }
  }

  # ── Regra 2: volume, nao conteudo ───────────────────────────────────────────
  # Bloqueia por CONTAGEM por IP numa janela deslizante. E a que pega o
  # scraping devagar e bem formado que passa pelas duas de cima.
  #
  # O limite abaixo NAO veio de benchmark de terceiro: veio da medicao de
  # trafego legitimo da Cadencia (secao de implantacao). Comece sempre em modo
  # COUNT (abaixo) e so troque para BLOCK depois de revisar a amostra.
  rule {
    name     = "limite-por-ip"
    priority = 10

    action {
      count {} # troque para `block {}` depois de validar a amostra — ver provas.sh
    }

    statement {
      rate_based_statement {
        limit              = 2000 # requisicoes por IP na janela abaixo; NAO e preco, e configuracao
        evaluation_window_sec = 300 # 5 min — o padrao; valido tambem 60, 120, 600
        aggregate_key_type = "IP"
      }
    }

    visibility_config {
      cloudwatch_metrics_enabled = true
      metric_name                = "limitePorIp"
      sampled_requests_enabled   = true
    }
  }

  visibility_config {
    cloudwatch_metrics_enabled = true
    metric_name                = "${var.projeto}-borda"
    sampled_requests_enabled   = true
  }

  tags = local.tags
}

output "web_acl_arn" {
  value       = aws_wafv2_web_acl.borda.arn
  description = "ARN do WebACL; e o que a distribuicao referencia em web_acl_id"
}

# borda.tf — a MESMA distribuicao do L05, com uma linha nova

# Para o escopo CLOUDFRONT nao existe `aws_wafv2_web_acl_association` — esse
# recurso e so para alvo REGIONAL (ALB, API Gateway). A associacao acontece
# apontando `web_acl_id` direto na distribuicao, para o ARN do WebACL.
resource "aws_cloudfront_distribution" "borda" {
  # ... todos os argumentos que o L05 ja declara (origins, comportamentos,
  # certificado, aliases) continuam aqui, sem mudanca nenhuma ...

  web_acl_id = aws_wafv2_web_acl.borda.arn # a unica linha nova neste recurso

  # Nao ha dependencia explicita necessaria: o Terraform já infere a ordem
  # pela referencia ao ARN do WebACL no atributo acima.
}

# log-waf.tf — para onde vai cada decisao, bloqueada ou permitida

# O nome do bucket de destino de log do WAF E OBRIGADO a comecar com
# "aws-waf-logs-" — e uma exigencia documentada, nao uma convencao de estilo.
# Sem o prefixo certo, a configuracao de log falha na hora de aplicar.
resource "aws_s3_bucket" "log_waf" {
  bucket        = "aws-waf-logs-${var.projeto}-${data.aws_caller_identity.atual.account_id}"
  force_destroy = var.ambiente != "prod"
  tags          = local.tags
}

resource "aws_s3_bucket_public_access_block" "log_waf" {
  bucket                  = aws_s3_bucket.log_waf.id
  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

resource "aws_wafv2_web_acl_logging_configuration" "borda" {
  provider                = aws.borda # o log de um WebACL CLOUDFRONT tambem se configura em us-east-1
  resource_arn             = aws_wafv2_web_acl.borda.arn
  log_destination_configs = [aws_s3_bucket.log_waf.arn]

  # O cabecalho Authorization nunca vai para o log em texto claro. Redaction
  # e por campo — aqui, um unico cabecalho — nao existe "redija tudo".
  redacted_fields {
    single_header {
      name = "authorization"
    }
  }
}

// Program.cs — a segunda camada, e por que ela NAO substitui o WAF

var builder = WebApplication.CreateBuilder(args);

// O limitador embutido do ASP.NET Core protege uma dependencia especifica —
// aqui, o pool de conexao do banco no endpoint de login — de ser esgotada por
// tentativa repetida. Ele NAO evita o custo de computacao da requisicao: no
// momento em que este middleware decide negar, o Fargate ja recebeu a
// requisicao, ja passou pelo pipeline ate aqui, e ja foi cobrado por isso.
builder.Services.AddRateLimiter(o =>
{
    o.RejectionStatusCode = StatusCodes.Status429TooManyRequests;

    o.AddFixedWindowLimiter("login", opcoes =>
    {
        // Por USUARIO ANONIMO nao existe particionamento identificavel antes
        // do login — a janela abaixo e por conexao, o que e mais grosseiro
        // que a regra de taxa por IP do WAF. E complementar, nao substituto.
        opcoes.PermitLimit = 5;
        opcoes.Window = TimeSpan.FromMinutes(1);
        opcoes.QueueLimit = 0; // sem fila: negar rapido custa menos que enfileirar
    });
});

var app = builder.Build();
app.UseRateLimiter();

app.MapPost("/api/login", async (CredenciaisDto c, IServicoDeLogin login) =>
    await login.AutenticarAsync(c) is { } sessao
        ? Results.Ok(sessao)
        : Results.Unauthorized())
    .RequireRateLimiting("login");

app.Run();

#!/usr/bin/env bash
# simular-bot.sh — a mesma rajada, contra os dois desenhos
set -euo pipefail

URL="https://$(terraform output -raw dominio)/api/login"
TOTAL="${1:-5000}"

# Rajada de POST invalido, paralela, imitando um bot de credential stuffing.
# Contra o desenho MINIMO, cada uma destas chega a task.
seq 1 "$TOTAL" | xargs -P 50 -I{} \
  curl -s -o /dev/null -w '%{http_code}\n' \
    -X POST "$URL" -H 'Content-Type: application/json' \
    -d '{"usuario":"teste","senha":"errada"}' \
  > /tmp/codigos-rajada.txt

echo "total de requisicoes: $(wc -l < /tmp/codigos-rajada.txt)"
echo "por codigo:"
sort /tmp/codigos-rajada.txt | uniq -c
# Contra o desenho MINIMO: quase tudo em 401 — cada uma computada.
# Contra o desenho de PRODUCAO: uma fatia crescente em 403 — bloqueada na borda.

# provas.sh — cinco medições; nenhuma conclusão vem de "parece bloqueado"

WEBACL=$(aws wafv2 list-web-acls --scope CLOUDFRONT --region us-east-1 \
  --query "WebACLs[?Name=='ffv-lab-borda'].Id" --output text)

# ── Prova 1: com o desenho MINIMO, a rajada chega inteira à task ────────────
# Rode antes de associar o WebACL. O CPUUtilization da task sobe junto com o
# volume, e a contagem de 401 no ALB bate com o total enviado.
./simular-bot.sh 5000
aws cloudwatch get-metric-statistics \
  --namespace AWS/ECS --metric-name CPUUtilization \
  --dimensions Name=ServiceName,Value=ffv-lab-api Name=ClusterName,Value=ffv-lab \
  --start-time "$(date -u -d '-10 min' +%FT%TZ)" --end-time "$(date -u +%FT%TZ)" \
  --period 60 --statistics Maximum --output table
# Esperado: pico visível de CPU coincidindo com a janela da rajada.

# ── Prova 2: com o WebACL em Count, nada é bloqueado ainda ──────────────────
# A métrica de contaria acumula, mas AllowedRequests continua igual ao total.
aws cloudwatch get-metric-statistics --region us-east-1 \
  --namespace AWS/WAFV2 --metric-name CountedRequests \
  --dimensions Name=WebACL,Value=ffv-lab-borda Name=Region,Value=CloudFront Name=Rule,Value=limitePorIp \
  --start-time "$(date -u -d '-10 min' +%FT%TZ)" --end-time "$(date -u +%FT%TZ)" \
  --period 60 --statistics Sum --output table
# Esperado: CountedRequests > 0. Nenhuma requisição foi de fato barrada ainda.

# ── Prova 3: depois de trocar para Block, a rajada é interrompida na borda ──
./simular-bot.sh 5000
aws cloudwatch get-metric-statistics --region us-east-1 \
  --namespace AWS/WAFV2 --metric-name BlockedRequests \
  --dimensions Name=WebACL,Value=ffv-lab-borda Name=Region,Value=CloudFront Name=Rule,Value=limitePorIp \
  --start-time "$(date -u -d '-10 min' +%FT%TZ)" --end-time "$(date -u +%FT%TZ)" \
  --period 60 --statistics Sum --output table
# Esperado: BlockedRequests próximo do total enviado, acima do limite de 2.000.

# ── Prova 4: a task não viu a parte bloqueada da rajada ─────────────────────
# Compare a contagem de requisições no log do ALB com o total enviado.
aws logs filter-log-events --log-group-name /ecs/ffv-lab-api \
  --start-time "$(date -d '-10 min' +%s000)" \
  --filter-pattern "/api/login" --query 'length(events)' --output text
# Esperado: bem menor que o total de 5.000 — a diferença é o que a borda reteve.

# ── Prova 5: o cliente legítimo não percebeu nada ───────────────────────────
for i in $(seq 1 20); do
  curl -s -o /dev/null -w '%{http_code} ' \
    "https://$(terraform output -raw dominio)/api/pedidos/00000000-0000-0000-0000-000000000000"
done
echo
# Esperado: fileira de 200/404 normais, sem nenhum 403 — o cliente não usa o
# endpoint de login em rajada e não se parece com o padrão da regra de taxa.

# 1. Derrube o que o Terraform administra.
terraform destroy -auto-approve

# 2. BUCKET DE LOG DO WAF: se `force_destroy` estiver desligado, o destroy falha
#    com o bucket cheio, e ele fica de pe cobrando GB armazenado.
aws s3 ls | grep aws-waf-logs
aws s3 rm "s3://aws-waf-logs-ffv-lab-<conta>" --recursive 2>/dev/null || true
aws s3api delete-bucket --bucket "aws-waf-logs-ffv-lab-<conta>" 2>/dev/null || true

# 3. Confirme que o WebACL, criado em us-east-1, realmente saiu — regiao errada
#    na consulta e o motivo mais comum de "esqueci de apagar".
aws wafv2 list-web-acls --scope CLOUDFRONT --region us-east-1 \
  --query "WebACLs[?Name=='ffv-lab-borda']" --output table

# 4. O que veio do L05 e do L01 continua cobrando por hora se voce nao for
#    seguir para outro laboratorio: CloudFront, ALB, RDS, NAT Gateway.
#    Rode a limpeza deles tambem.

# 5. Prova final: nada com o nome do projeto de pe.
aws resourcegroupstaggingapi get-resources \
  --tag-filters Key=Projeto,Values=ffv-lab \
  --query "ResourceTagMappingList[].ResourceARN" --output table