Lab 48 — Detecção: GuardDuty, Security Hub, Config

// O que o EventBridge entrega quando o Security Hub importa um achado.
// E o payload que a funcao de ticket le para calcular o prazo.
{
  "version": "0",
  "id": "6a7e8f2c-...",
  "detail-type": "Security Hub Findings - Imported",
  "source": "aws.securityhub",
  "account": "111122223333",
  "time": "2026-08-07T14:03:11Z",
  "region": "us-east-1",
  "detail": {
    "findings": [
      {
        "Id": "arn:aws:guardduty:us-east-1:111122223333:detector/abc/finding/xyz",
        "ProductArn": "arn:aws:securityhub:us-east-1::product/aws/guardduty",
        "GeneratorId": "arn:aws:guardduty:us-east-1:111122223333:detector/abc",
        // O tipo e o que a funcao usa para decidir se e AUTOMATIZAVEL.
        "Types": ["CryptoCurrency:EC2/BitcoinTool.B!DNS"],
        "Severity": { "Label": "CRITICAL", "Normalized": 90 },
        // NEW e o unico status que a regra do EventBridge deixa passar.
        "Workflow": { "Status": "NEW" },
        "Resources": [
          { "Type": "AwsEc2Instance", "Id": "arn:aws:ec2:us-east-1:111122223333:instance/i-0abc" }
        ],
        "FirstObservedAt": "2026-08-07T14:02:40Z",
        "UpdatedAt": "2026-08-07T14:02:40Z"
      }
    ]
  }
}

# detectores.tf — dois detectores, dois papeis que nao se substituem

# GuardDuty ja analisa CloudTrail de gerenciamento, VPC Flow Logs e logs de
# DNS por padrao, sem nenhuma configuracao adicional — e essa parte este
# laboratorio NAO precisa construir; ela ja existe no momento em que o
# detector e criado.
resource "aws_guardduty_detector" "principal" {
  enable = true

  # O minimo suportado. Isto controla so a cadencia de REEXPORTACAO de um
  # achado JA EXISTENTE que foi atualizado (ex: nova evidencia no mesmo
  # achado) — um achado NOVO publica no EventBridge perto de tempo real,
  # independente deste valor. Ainda assim vale o minimo: quando o mesmo
  # achado ganha evidencia nova, 15 min bate melhor no SLA do que o padrao
  # de 6 horas do console.
  finding_publishing_frequency = "FIFTEEN_MINUTES"
}

# AWS Config avalia CONFIGURACAO, nao comportamento. Precisa de um gravador
# antes de qualquer regra ter o que avaliar contra.
resource "aws_config_configuration_recorder" "principal" {
  name     = "${var.projeto}-config"
  role_arn = aws_iam_role.config.arn

  recording_group {
    # Gravar so os tipos que as regras deste laboratorio avaliam evita o
    # custo oculto de gravar item de configuracao que ninguem audita — o
    # Config cobra por item gravado, nao por regra.
    all_supported   = false
    resource_types  = ["AWS::S3::Bucket", "AWS::IAM::Role"]
  }
}

resource "aws_config_delivery_channel" "principal" {
  name           = "${var.projeto}-config"
  s3_bucket_name = aws_s3_bucket.config.id
  depends_on     = [aws_config_configuration_recorder.principal]
}

resource "aws_config_configuration_recorder_status" "principal" {
  name       = aws_config_configuration_recorder.principal.name
  is_enabled = true
  depends_on = [aws_config_delivery_channel.principal]
}

# A regra gerenciada da AWS para bloqueio de acesso publico em bucket S3.
# O ponto central deste laboratorio: DOIS gatilhos, nao um so.
resource "aws_config_config_rule" "bucket_sem_acesso_publico" {
  name = "${var.projeto}-s3-bloqueio-publico"

  source {
    owner             = "AWS"
    source_identifier = "S3_BUCKET_LEVEL_PUBLIC_ACCESS_PROHIBITED"
  }

  scope {
    compliance_resource_types = ["AWS::S3::Bucket"]
  }

  # Gatilho por MUDANCA: reavalia no instante em que a configuracao do
  # bucket muda. E o que pega o bucket que ficou publico as 14h32.
  #
  # Gatilho PERIODICO (abaixo, via maximum_execution_frequency implicito de
  # 24h no console; aqui explicito para nao depender do padrao) e a rede de
  # seguranca — cobre o que a notificacao de mudanca eventualmente perder.
  # Um so dos dois deixa janela: so periodico, ate 24h sem detectar; so
  # mudanca, um evento perdido nunca e corrigido.
  maximum_execution_frequency = "TwentyFour_Hours"

  depends_on = [aws_config_configuration_recorder.principal]
}

output "detector_guardduty" {
  value       = aws_guardduty_detector.principal.id
  description = "ID do detector — usado para gerar achado de teste na secao de provas"
}

# securityhub.tf — o agregador; nao detecta nada, normaliza e da o placar

resource "aws_securityhub_account" "principal" {
  # Habilita SO o padrao que decidimos avaliar (abaixo), nao os dois
  # principais de uma vez. Cada padrao ligado multiplica o numero de
  # verificacoes de conformidade rodadas — e e cobrado por verificacao.
  enable_default_standards = false
}

resource "aws_securityhub_standards_subscription" "fsbp" {
  standards_arn = "arn:aws:securityhub:${var.regiao}::standards/aws-foundational-security-best-practices/v/1.0.0"
  depends_on    = [aws_securityhub_account.principal]
}

# GuardDuty e Config publicam para o Security Hub por integracao nativa: nao
# existe um recurso Terraform de "assinatura de produto" para os dois porque
# a assinatura e automatica quando ambos estao habilitados na mesma conta e
# regiao que o Security Hub. Assinatura explicita de produto so existe para
# integracao de terceiro.

# resposta.tf — o gatilho por severidade, o ticket e o freio de aprovacao

resource "aws_dynamodb_table" "tickets" {
  name         = "${var.projeto}-tickets-seguranca"
  # Sob demanda: o volume de achado e picos imprevisiveis (uma varredura
  # externa gera dezenas de achados no mesmo minuto). Capacidade provisionada
  # aqui e estimar um numero que nao existe.
  billing_mode = "PAY_PER_REQUEST"
  hash_key     = "achado_id"

  attribute {
    name = "achado_id"
    type = "S"
  }
}

resource "aws_cloudwatch_event_rule" "achado_critico_ou_alto" {
  name = "${var.projeto}-achado-critico-alto"

  # O MESMO detail-type dispara para achado novo e para achado atualizado —
  # e por isso o filtro de Workflow.Status = NEW e o que evita reabrir um
  # ticket a cada reavaliacao do mesmo achado sem mudanca real.
  event_pattern = jsonencode({
    source        = ["aws.securityhub"]
    "detail-type" = ["Security Hub Findings - Imported"]
    detail = {
      findings = {
        Severity = { Label = ["CRITICAL", "HIGH"] }
        Workflow = { Status = ["NEW"] }
      }
    }
  })
}

resource "aws_cloudwatch_event_target" "para_a_funcao_de_ticket" {
  rule      = aws_cloudwatch_event_rule.achado_critico_ou_alto.name
  target_id = "funcao-ticket"
  arn       = aws_lambda_function.ticket.arn
}

resource "aws_lambda_permission" "eventbridge_invoca" {
  statement_id  = "PermiteEventBridge"
  action        = "lambda:InvokeFunction"
  function_name = aws_lambda_function.ticket.function_name
  principal     = "events.amazonaws.com"
  source_arn    = aws_cloudwatch_event_rule.achado_critico_ou_alto.arn
}

resource "aws_lambda_function" "ticket" {
  function_name = "${var.projeto}-ticket-seguranca"
  role          = aws_iam_role.ticket_lambda.arn
  handler       = "TicketSeguranca::TicketSeguranca.Function::FunctionHandler"
  runtime       = "dotnet8"
  timeout       = 15
  filename      = data.archive_file.ticket.output_path

  environment {
    variables = {
      TABELA_TICKETS         = aws_dynamodb_table.tickets.name
      ARN_MAQUINA_APROVACAO  = aws_sfn_state_machine.aprovacao.arn
    }
  }
}

resource "aws_sfn_state_machine" "aprovacao" {
  name     = "${var.projeto}-aprovacao-contencao"
  role_arn = aws_iam_role.step_functions.arn
  # Definicao completa na secao seguinte — e o freio para o irreversivel.
  definition = file("${path.module}/aprovacao.asl.json")
}

# Menor privilegio: PutItem/GetItem/UpdateItem restritos a UMA tabela — nao
# dynamodb:* e nao Resource "*". E o habito que o L41 existe para instalar,
# e que copiar uma role generica reabriria.
data "aws_iam_policy_document" "ticket_lambda" {
  statement {
    effect    = "Allow"
    actions   = ["dynamodb:PutItem", "dynamodb:GetItem", "dynamodb:UpdateItem"]
    resources = [aws_dynamodb_table.tickets.arn]
  }
  statement {
    effect    = "Allow"
    actions   = ["states:StartExecution"]
    resources = [aws_sfn_state_machine.aprovacao.arn]
  }
  statement {
    effect = "Allow"
    # PutMetricData nao aceita recurso especifico: e operacao de namespace de
    # metrica, nao de recurso individual. E por isso que o "*" aparece aqui,
    # e em nenhum outro lugar desta policy.
    actions   = ["cloudwatch:PutMetricData"]
    resources = ["*"]
  }
}

resource "aws_iam_role_policy" "ticket_lambda" {
  role   = aws_iam_role.ticket_lambda.id
  policy = data.aws_iam_policy_document.ticket_lambda.json
}

{
  "Comment": "Contencao de achado CRITICAL: para numa aprovacao antes de qualquer acao irreversivel",
  "StartAt": "AguardaAprovacao",
  "States": {
    "AguardaAprovacao": {
      "Type": "Task",
      "Resource": "arn:aws:states:::sns:publish.waitForTaskToken",
      "Parameters": {
        "TopicArn": "${var.arn_topico_aprovacao}",
        "Message.$": "$",
        "MessageAttributes": {
          "TaskToken": { "DataType": "String", "StringValue.$": "$$.Task.Token" }
        }
      },
      "TimeoutSeconds": 3600,
      "Next": "Decisao",
      "Catch": [
        { "ErrorEquals": ["States.Timeout"], "Next": "AprovacaoExpirou" }
      ]
    },
    "Decisao": {
      "Type": "Choice",
      "Choices": [
        { "Variable": "$.aprovado", "BooleanEquals": true, "Next": "ExecutaContencao" }
      ],
      "Default": "AprovacaoNegada"
    },
    "ExecutaContencao": {
      "Type": "Succeed"
    },
    "AprovacaoNegada": {
      "Type": "Fail",
      "Error": "AnalistaRejeitou",
      "Cause": "Analista revisou o achado e decidiu que a acao nao deve ser executada"
    },
    "AprovacaoExpirou": {
      "Type": "Fail",
      "Error": "SemRespostaEmUmaHora",
      "Cause": "Ninguem aprovou nem rejeitou dentro do prazo — o achado continua ABERTO no ticket"
    }
  }
}

// Function.cs — o Lambda que transforma achado em ticket com prazo

using Amazon.Lambda.Core;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
using Amazon.StepFunctions;
using Amazon.StepFunctions.Model;
using System.Text.Json;

[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]

namespace TicketSeguranca;

public record Severidade(string Label);
public record Achado(string Id, Severidade Severity, List<string> Types, List<object> Resources);
public record Findings(List<Achado> Findings);
public record EventoEventBridge(Findings Detail);

public class Function
{
    // SLA por severidade — nao existe UM prazo, existe uma tabela. Achado
    // LOW e INFORMATIONAL nem chegam aqui: o padrao do EventBridge ja os
    // filtra antes de esta funcao ser invocada.
    private static readonly Dictionary<string, TimeSpan> PrazoPorSeveridade = new()
    {
        ["CRITICAL"] = TimeSpan.FromMinutes(15),
        ["HIGH"]     = TimeSpan.FromHours(1),
    };

    private readonly AmazonDynamoDBClient _dynamo = new();
    private readonly AmazonStepFunctionsClient _stepFunctions = new();
    private readonly string _tabela = Environment.GetEnvironmentVariable("TABELA_TICKETS")!;
    private readonly string _maquinaAprovacao = Environment.GetEnvironmentVariable("ARN_MAQUINA_APROVACAO")!;

    public async Task FunctionHandler(EventoEventBridge evento, ILambdaContext contexto)
    {
        foreach (var achado in evento.Detail.Findings)
        {
            var agora = DateTimeOffset.UtcNow;
            var prazo = agora + PrazoPorSeveridade[achado.Severity.Label];

            // Idempotencia CORRETA: a chave inclui a severidade atual, nao
            // so o identificador do achado. Um achado que escala de MEDIUM
            // para CRITICAL muda de chave e gera um SEGUNDO registro com
            // prazo mais curto — em vez de esta funcao ignorar em silencio
            // a atualizacao porque "esse achado ja tem ticket". E o defeito
            // que a secao de falhas deste modulo provoca de proposito.
            var chave = $"{achado.Id}#{achado.Severity.Label}";

            await _dynamo.PutItemAsync(new PutItemRequest
            {
                TableName = _tabela,
                Item = new Dictionary<string, AttributeValue>
                {
                    ["achado_id"]  = new AttributeValue { S = chave },
                    ["severidade"] = new AttributeValue { S = achado.Severity.Label },
                    ["criado_em"]  = new AttributeValue { S = agora.ToString("O") },
                    ["prazo"]      = new AttributeValue { S = prazo.ToString("O") },
                    ["status"]     = new AttributeValue { S = "ABERTO" },
                    ["tipo"]       = new AttributeValue { S = achado.Types.FirstOrDefault() ?? "desconhecido" },
                },
                // Nao sobrescreve um ticket ja aberto para a MESMA chave —
                // mas uma chave nova (severidade diferente) sempre grava.
                ConditionExpression = "attribute_not_exists(achado_id)",
            });

            // So achado CRITICAL de um tipo conhecido como automatizavel
            // entra no fluxo de aprovacao. Esta funcao NUNCA executa a
            // contencao: ela apenas inicia a maquina de estados que vai
            // parar numa aprovacao humana antes de qualquer acao.
            if (achado.Severity.Label == "CRITICAL" && EhAutomatizavel(achado))
            {
                await _stepFunctions.StartExecutionAsync(new StartExecutionRequest
                {
                    StateMachineArn = _maquinaAprovacao,
                    Input = JsonSerializer.Serialize(new { achado.Id, achado.Resources }),
                });
            }
        }
    }

    // Lista curta e explicita, de proposito: contencao automatizada so se
    // propoe para tipos de achado onde a acao (isolar instancia, revogar
    // credencial) e conhecida e a equipe ja decidiu que quer o fluxo de
    // aprovacao para eles. Tipo fora da lista vira ticket, sem fluxo de
    // contencao — alguem decide manualmente o proximo passo.
    private static bool EhAutomatizavel(Achado achado) =>
        achado.Types.Any(t => t.StartsWith("CryptoCurrency") || t.StartsWith("UnauthorizedAccess"));
}

# provas.sh — cinco medicoes; nenhuma conclusao vem de "chegou o e-mail"

PROJETO=ffv-lab; REGIAO=us-east-1
DETECTOR=$(aws guardduty list-detectors --query 'DetectorIds[0]' --output text)

# ── Prova 1: o achado de teste realmente nasce no GuardDuty ──────────────────
aws guardduty create-sample-findings --detector-id "$DETECTOR" --region "$REGIAO"
sleep 30
aws guardduty list-findings --detector-id "$DETECTOR" \
  --query 'length(FindingIds)' --output text
# Esperado: numero maior que zero. Achados de amostra levam ate alguns
# minutos para aparecer — se vier zero, aguarde e repita antes de concluir falha.

# ── Prova 2: o mesmo achado aparece no Security Hub, normalizado ─────────────
aws securityhub get-findings \
  --filters '{"ProductName":[{"Value":"GuardDuty","Comparison":"EQUALS"}]}' \
  --query 'Findings[0].{Id:Id,Severidade:Severity.Label,Status:Workflow.Status}' \
  --output table
# Esperado: uma linha com Severidade preenchida. Vazio aqui significa que a
# integracao GuardDuty->Security Hub nao esta ativa nesta conta/regiao.

# ── Prova 3: o ticket nasce com prazo, nao so com conteudo ───────────────────
aws dynamodb scan --table-name "${PROJETO}-tickets-seguranca" \
  --query 'Items[0].{Severidade:severidade.S,Prazo:prazo.S,Status:status.S}' \
  --output table
# Esperado: campo Prazo preenchido, e igual a Criado_em mais o SLA da
# severidade — 15 min para CRITICAL, 1 h para HIGH. Prazo vazio e a
# funcao de ticket nao concluiu, ou o achado nao casou a regra do EventBridge.

# ── Prova 4: o caminho minimo (so e-mail) nao produz NENHUM registro ─────────
# Rode com a stack de producao DESLIGADA (so GuardDuty + SNS do desenho
# minimo) e repita a prova 1. Depois:
aws dynamodb scan --table-name "${PROJETO}-tickets-seguranca" \
  --query 'length(Items)' --output text 2>/dev/null || echo "tabela nao existe"
# Esperado: "tabela nao existe", ou 0 itens. E a prova de que o e-mail,
# sozinho, nunca produziu acao rastreavel nenhuma.

# ── Prova 5: a aprovacao humana realmente bloqueia a contencao ───────────────
aws stepfunctions list-executions \
  --state-machine-arn "$(terraform output -raw arn_maquina_aprovacao)" \
  --status-filter RUNNING \
  --query 'executions[].{Iniciada:startDate,Status:status}' --output table
# Esperado, para achado CRITICAL automatizavel: uma execucao em RUNNING,
# parada no estado AguardaAprovacao, ate alguem responder ou o prazo de
# 1 h expirar. Se o status for SUCCEEDED sem ninguem ter aprovado, o freio
# nao esta funcionando.

#!/usr/bin/env bash
# limpar.sh — a ordem importa; achado do GuardDuty sobrevive ao Terraform
set -euo pipefail

PROJETO="${PROJETO:?defina PROJETO}"

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

# 2. CONFORMIDADE DE ACHADOS: os 90 dias de retencao SO valem com o detector
#    ATIVO ou SUSPENSO. Deletar o detector — que e o que este destroy faz —
#    PERDE os achados existentes; a AWS e explicita que a configuracao e os
#    achados "sao perdidos e nao podem ser recuperados". Se voce precisa do
#    historico, exporte para S3 ANTES do destroy; depois dele, nao ha achado
#    nenhum para consultar, retido ou nao.
echo "ATENCAO: deletar o detector do GuardDuty PERDE os achados existentes"
echo "— a retencao de 90 dias so vale com o detector vivo. Exporte para S3"
echo "ANTES deste destroy se o historico importa; depois, nao ha mais o que buscar."

# 3. BUCKET DO CONFIG: guarda snapshot de configuracao e nao esvazia sozinho.
aws s3 rm "s3://${PROJETO}-config" --recursive 2>/dev/null || true
aws s3api delete-bucket --bucket "${PROJETO}-config" 2>/dev/null || true

# 4. PADRAO DO SECURITY HUB: a assinatura do padrao (FSBP) para de rodar
#    verificacao com o destroy, mas confirme — verificacao ja em andamento
#    no momento do destroy pode ser cobrada.
aws securityhub get-enabled-standards --query 'StandardsSubscriptions' --output table 2>/dev/null || \
  echo "Security Hub ja desabilitado nesta conta/regiao."

# 5. TABELA DE TICKETS: contem achado ABERTO sem resolucao. Exporte antes de
#    apagar, ou a rastreabilidade que este laboratorio existe para criar
#    desaparece junto com a tabela.
aws dynamodb scan --table-name "${PROJETO}-tickets-seguranca" \
  --query 'Items[?status.S==`ABERTO`]' --output json > tickets-abertos-backup.json 2>/dev/null || true

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