Lab 50 — Resposta a incidente e blast radius

# investigar-na-mao.sh — o cenario NAIVE (secao "Arquitetura minima"), sem
# Athena, sem trilha organizacional, sem segunda contencao. Rodado numa
# simulacao de mesa (game day) da FFV Academy, em conta de teste — os
# numeros sao ORDEM DE GRANDEZA do efeito da ordem errada, nao benchmark.
INICIO=$(date +%s)

# Baixar TODOS os objetos do dia, de uma trilha so-local (sem organizacao).
aws s3 sync s3://cadencia-dev-trilha/AWSLogs/111122223333/CloudTrail/us-east-1/2026/08/07 ./bruto/
# 612 objetos .json.gz so nesse dia, ~410 MB comprimidos, so nesta conta.

# Descompactar e filtrar a mao, um por um.
for f in ./bruto/*.json.gz; do
  zcat "$f" | grep -o '"accessKeyId":"AKIA[A-Z0-9]*"'
done | sort | uniq -c

FIM_BUSCA=$(date +%s)
echo "so a busca: $(( (FIM_BUSCA-INICIO)/60 )) min"
# Nesta simulacao: 96 min so para isolar as linhas da chave comprometida — e
# isso SEM separar por conta, sem seguir AssumeRole, sem nada estruturado.

# So DEPOIS disso alguem decide desativar a chave:
aws iam update-access-key --user-name svc-manutencao --access-key-id AKIAEXEMPLO1234567 --status Inactive
FIM=$(date +%s)
echo "tempo total ate a (unica) contencao: $(( (FIM-INICIO)/60 )) min"
# Nesta simulacao: 130 min. A sessao que a chave ja tinha emitido? Nunca
# verificada, e nunca contida — ninguem sabia que precisava procurar por ela.

{
  "source": "aws.guardduty",
  "detail-type": "GuardDuty Finding",
  "account": "111122223333",
  "region": "us-east-1",
  "detail": {
    "severity": 8.0,
    "type": "UnauthorizedAccess:IAMUser/InstanceCredentialExfiltration.OutsideAWS",
    "resource": {
      "resourceType": "AccessKey",
      "accessKeyDetails": {
        "accessKeyId": "AKIAEXEMPLO1234567",
        "principalId": "AIDAEXEMPLO",
        "userName": "svc-manutencao",
        "userType": "IAMUser"
      }
    },
    "description": "API GetSessionToken foi invocada de um IP fora do padrao observado."
  }
}

# trilha-organizacional.tf — aplica-se na conta de GESTAO da Organizations
# (a mesma landing zone do L43). Uma trilha, todas as contas-membro: e o que
# torna a consulta desta secao valida para QUALQUER conta, sem depender de
# disciplina individual em cada uma.

resource "aws_cloudtrail" "organizacional" {
  name                        = "cadencia-trilha-organizacional"
  is_organization_trail       = true   # so a conta de gestao pode setar isto
  is_multi_region_trail       = true
  enable_log_file_validation  = true   # assina digest por hora; e a base para provar integridade depois
  s3_bucket_name              = aws_s3_bucket.log_archive.id
  kms_key_id                  = aws_kms_key.log_archive.arn

  event_selector {
    read_write_type           = "All"
    include_management_events = true
    # Eventos de DADO (leitura/escrita de objeto S3, invocacao de Lambda) nao
    # entram aqui: cobram por milhao de eventos, e o requisito deste laboratorio
    # e reconstruir CHAMADA DE API, nao acesso a objeto. Liga-los e decisao
    # separada, do dono do bucket que guarda o dado sensivel (proximo do L49).
  }
}

# CONTA DE LOG ARCHIVE — separada da de gestao e das de carga de trabalho,
# a mesma landing zone do L43. Guardar aqui, e nao na conta de gestao, e o
# que limita quem tem acesso de LEITURA as evidencias.
resource "aws_s3_bucket" "log_archive" {
  bucket = "cadencia-log-archive-${data.aws_caller_identity.atual.account_id}"
}

resource "aws_s3_bucket_versioning" "log_archive" {
  bucket = aws_s3_bucket.log_archive.id
  versioning_configuration { status = "Enabled" }
}

# Object Lock em modo GOVERNANCE: ninguem, nem quem tem permissao de S3,
# sobrescreve ou apaga um objeto de log dentro do periodo de retencao sem uma
# permissao adicional explicita. E o que da a trilha o direito de ser chamada
# de evidencia — o mesmo requisito que o L97 formaliza para decisao de IA.
# ATENCAO: so pode ser ligado na CRIACAO do bucket; e a razao de aparecer aqui
# e nao como uma mudanca posterior.
resource "aws_s3_bucket_object_lock_configuration" "log_archive" {
  bucket = aws_s3_bucket.log_archive.id
  rule {
    default_retention {
      mode = "GOVERNANCE"
      days = 400
    }
  }
}

resource "aws_s3_bucket_policy" "log_archive" {
  bucket = aws_s3_bucket.log_archive.id
  policy = data.aws_iam_policy_document.permite_cloudtrail.json
}

data "aws_iam_policy_document" "permite_cloudtrail" {
  statement {
    sid       = "PermiteEntregaDaOrganizacao"
    effect    = "Allow"
    actions   = ["s3:PutObject"]
    resources = ["${aws_s3_bucket.log_archive.arn}/AWSLogs/*/CloudTrail/*"]

    principals {
      type        = "Service"
      identifiers = ["cloudtrail.amazonaws.com"]
    }

    condition {
      test     = "StringEquals"
      variable = "s3:x-amz-acl"
      values   = ["bucket-owner-full-control"]
    }
    condition {
      # Restringe a QUALQUER conta da organizacao, nao a uma conta especifica —
      # e o que faz a trilha aceitar entrega de conta nova (uma OU futura do
      # L56) sem editar esta policy.
      test     = "StringEquals"
      variable = "aws:SourceOrgID"
      values   = [data.aws_organizations_organization.atual.id]
    }
  }
}

# investigacao.tf — o catalogo e a consulta prontos, na conta de Log Archive.
#
# A tabela replica a DDL oficial da AWS para CloudTrail com projecao de
# particao (docs.aws.amazon.com/athena/latest/ug/create-cloudtrail-table-partition-projection.html),
# com uma diferenca: a documentacao mostra LOCATION com uma conta fixa no
# caminho. Aqui a trilha e ORGANIZACIONAL — cada conta-membro grava no MESMO
# bucket, sob o proprio prefixo AWSLogs/<conta>/. A projecao varre por
# timestamp; o filtro por conta acontece na clausula WHERE da consulta.
resource "aws_glue_catalog_database" "resposta_incidente" {
  name = "resposta_incidente"
}

resource "aws_glue_catalog_table" "cloudtrail" {
  name          = "eventos_organizacao"
  database_name = aws_glue_catalog_database.resposta_incidente.name
  table_type    = "EXTERNAL_TABLE"

  parameters = {
    "projection.enabled"                 = "true"
    "projection.timestamp.type"          = "date"
    "projection.timestamp.format"        = "yyyy/MM/dd"
    "projection.timestamp.interval"      = "1"
    "projection.timestamp.interval.unit" = "DAYS"
    "projection.timestamp.range"         = "2026/01/01,NOW"
    "storage.location.template"          = "s3://${aws_s3_bucket.log_archive.id}/AWSLogs/$${timestamp}"
    "classification"                     = "cloudtrail"
  }

  storage_descriptor {
    location      = "s3://${aws_s3_bucket.log_archive.id}/AWSLogs/"
    input_format  = "com.amazon.emr.cloudtrail.CloudTrailInputFormat"
    output_format = "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat"

    ser_de_info {
      serialization_library = "org.apache.hive.hcatalog.data.JsonSerDe"
    }

    # So os campos que este runbook realmente le. A tabela completa da AWS
    # tem mais de vinte; declarar so os usados aqui reduz a chance de alguem
    # escrever consulta sobre um campo que nunca foi testado.
    columns { name = "eventtime";          type = "string" }
    columns { name = "eventsource";        type = "string" }
    columns { name = "eventname";          type = "string" }
    columns { name = "awsregion";          type = "string" }
    columns { name = "recipientaccountid"; type = "string" }
    columns { name = "errorcode";          type = "string" }
    columns { name = "responseelements";   type = "string" }
    columns {
      name = "useridentity"
      type = "struct<type:string,principalid:string,arn:string,accountid:string,accesskeyid:string,username:string,sessioncontext:struct<sessionissuer:struct<type:string,arn:string,username:string>>>"
    }
  }

  partition_keys {
    name = "timestamp"
    type = "string"
  }
}

resource "aws_athena_workgroup" "resposta_incidente" {
  name = "resposta-a-incidente"

  configuration {
    enforce_workgroup_configuration    = true
    publish_cloudwatch_metrics_enabled = true

    result_configuration {
      output_location = "s3://${aws_s3_bucket.resultados_athena.id}/consultas/"
      encryption_configuration {
        encryption_option = "SSE_KMS"
        kms_key_arn        = aws_kms_key.log_archive.arn
      }
    }

    # Teto de dado varrido por consulta. Nao impede a investigacao — impede
    # que uma consulta escrita errada (sem filtro de particao de tempo) varra
    # o historico inteiro e gere uma fatura de investigacao maior que o
    # proprio incidente.
    bytes_scanned_cutoff_per_query = 5368709120 # 5 GiB
  }
}

resource "aws_athena_named_query" "raio_de_alcance" {
  name        = "raio-de-alcance-por-chave"
  workgroup   = aws_athena_workgroup.resposta_incidente.id
  database    = aws_glue_catalog_database.resposta_incidente.name
  description = "Toda chamada de uma accessKeyId, em toda conta, na janela do incidente."

  query = <<-SQL
    SELECT recipientaccountid, eventtime, eventsource, eventname, errorcode,
           useridentity.username, useridentity.accesskeyid,
           useridentity.sessioncontext.sessionissuer.arn AS role_assumida
    FROM eventos_organizacao
    WHERE useridentity.accesskeyid = ?
      AND timestamp BETWEEN ? AND ?
    ORDER BY eventtime ASC
  SQL
}

# resposta-incidente.tf — o papel do responsavel de plantao. Nasce estreito,
# e cada acao aqui e exatamente a que o runbook chama — nada de "por garantia".
data "aws_iam_policy_document" "responsavel_incidente" {
  statement {
    sid    = "ContencaoDaChave"
    effect = "Allow"
    actions = [
      "iam:UpdateAccessKey",       # contencao 1: desativa a chave
      "iam:GetAccessKeyLastUsed",  # confirma que a acao teve efeito
      "iam:ListAccessKeys",
    ]
    # ListAccessKeys nao aceita ARN de chave especifica — so de usuario — e e
    # por isso que o recurso cobre o usuario, nao uma chave isolada.
    resources = ["arn:aws:iam::*:user/*"]
  }

  statement {
    sid    = "ContencaoDaSessao"
    effect = "Allow"
    actions = [
      "iam:PutUserPolicy", # contencao 2, quando a origem e um usuario IAM
      "iam:PutRolePolicy", # contencao 2, quando o encadeamento chega a um papel
    ]
    resources = ["arn:aws:iam::*:user/*", "arn:aws:iam::*:role/*"]
    condition {
      # So autoriza anexar UMA politica com este nome — a que o runbook usa.
      # Nao autoriza reescrever qualquer politica inline com qualquer conteudo.
      test     = "StringEquals"
      variable = "iam:PolicyName"
      values   = ["ContencaoDeIncidente"]
    }
  }

  statement {
    sid    = "InvestigacaoPorAthena"
    effect = "Allow"
    actions = [
      "athena:StartQueryExecution",
      "athena:GetQueryExecution",
      "athena:GetQueryResults",
      "athena:GetNamedQuery",
    ]
    resources = [aws_athena_workgroup.resposta_incidente.arn]
  }

  statement {
    sid    = "LeituraDoCatalogo"
    effect = "Allow"
    actions = ["glue:GetTable", "glue:GetDatabase", "glue:GetPartitions"]
    resources = [
      "arn:aws:glue:*:*:catalog",
      aws_glue_catalog_database.resposta_incidente.arn,
      aws_glue_catalog_table.cloudtrail.arn,
    ]
  }

  statement {
    sid    = "LeituraDoLogEEscritaDoResultado"
    effect = "Allow"
    actions = ["s3:GetObject", "s3:ListBucket"]
    resources = [
      aws_s3_bucket.log_archive.arn,
      "${aws_s3_bucket.log_archive.arn}/*",
      aws_s3_bucket.resultados_athena.arn,
      "${aws_s3_bucket.resultados_athena.arn}/*",
    ]
  }

  statement {
    sid       = "IdentificarQuemEstaChamando"
    effect    = "Allow"
    actions   = ["sts:GetCallerIdentity"]
    # GetCallerIdentity nao aceita recurso: e uma operacao que so descreve
    # quem fez a chamada, nao acessa nada de ninguem. E o unico "*" desta
    # politica, e o motivo e sempre o mesmo: a acao nao suporta ARN.
    resources = ["*"]
  }
}

resource "aws_iam_role" "responsavel_incidente" {
  name                  = "cadencia-responsavel-incidente"
  max_session_duration  = 3600 # 1h: sessao curta para quem age sobre um incidente

  # Simplificado para confianca na propria conta + MFA obrigatoria: o binding
  # fino de QUEM pode assumir este papel e o permission set do Identity
  # Center provisionado no L43, reaproveitado aqui — nao redeclarado, para nao
  # divergir da fonte unica.
  assume_role_policy = data.aws_iam_policy_document.confianca_responsavel.json
}

data "aws_iam_policy_document" "confianca_responsavel" {
  statement {
    effect  = "Allow"
    actions = ["sts:AssumeRole"]
    principals {
      type        = "AWS"
      identifiers = ["arn:aws:iam::${data.aws_caller_identity.atual.account_id}:root"]
    }
    condition {
      test     = "Bool"
      variable = "aws:MultiFactorAuthPresent"
      values   = ["true"]
    }
  }
}

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

// RunbookIncidente.cs — o runbook executavel: contem, depois investiga, e
// cronometra os dois. Roda como `dotnet run -- <accessKeyId> <nomeDoUsuario>`.
//
// A ORDEM das chamadas abaixo NAO e incidental: as duas contencoes acontecem
// ANTES de a consulta ao Athena comecar. Trocar a ordem e reproduzir, em
// codigo, o erro que o cenario ingenuo da secao 5 cometeu a mao.

using System.Diagnostics;
using Amazon.Athena;
using Amazon.Athena.Model;
using Amazon.IdentityManagement;
using Amazon.IdentityManagement.Model;

if (args.Length < 2)
{
    Console.Error.WriteLine("uso: dotnet run -- <accessKeyId> <nomeDoUsuario>");
    return 1;
}

var accessKeyId = args[0];
var nomeDoUsuario = args[1];
var cronometro = Stopwatch.StartNew();

using var iam = new AmazonIdentityManagementServiceClient();
using var athena = new AmazonAthenaClient();

// ── Contenção 1: a chave para de assinar qualquer coisa nova ────────────────
// Desativar, nunca apagar: apagar destroi a possibilidade de reverter um
// falso positivo e some com metadado que a investigacao ainda pode precisar.
await iam.UpdateAccessKeyAsync(new UpdateAccessKeyRequest
{
    UserName = nomeDoUsuario,
    AccessKeyId = accessKeyId,
    Status = StatusType.Inactive,
});
var t1 = cronometro.Elapsed;
Console.WriteLine($"[contenção 1] chave {accessKeyId} inativa em {t1.TotalSeconds:F1}s");

// ── Contenção 2: a sessão que a chave já emitiu também morre ────────────────
// Documentado pela AWS para papéis (botão "Revoke active sessions", que
// anexa a política AWSRevokeOlderSessions). Para um usuário IAM, o mesmo
// mecanismo — Deny condicionado a aws:TokenIssueTime — se aplica anexando a
// política diretamente a ele: qualquer credencial TEMPORÁRIA que a chave já
// tenha emitido (via AssumeRole ou GetSessionToken) para de funcionar; a
// própria chave de longa duração já foi tratada pela contenção 1.
var agora = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
var negaSessoesAntigas = $$"""
{
  "Version": "2012-10-17",
  "Statement": {
    "Sid": "NegaSessaoEmitidaAntesDaContencao",
    "Effect": "Deny",
    "Action": "*",
    "Resource": "*",
    "Condition": { "DateLessThan": { "aws:TokenIssueTime": "{{agora}}" } }
  }
}
""";

await iam.PutUserPolicyAsync(new PutUserPolicyRequest
{
    UserName = nomeDoUsuario,
    PolicyName = "ContencaoDeIncidente",
    PolicyDocument = negaSessoesAntigas,
});
var t2 = cronometro.Elapsed;
Console.WriteLine($"[contenção 2] sessões emitidas antes de {agora} negadas em {t2.TotalSeconds:F1}s");
Console.WriteLine("propagação: até ~30s antes de valer em todas as regiões — repita a prova depois desse teto");

// ── Investigação: só agora, e em paralelo ao resto do runbook ───────────────
var execucao = await athena.StartQueryExecutionAsync(new StartQueryExecutionRequest
{
    QueryExecutionContext = new QueryExecutionContext { Database = "resposta_incidente" },
    WorkGroup = "resposta-a-incidente",
    QueryString = """
        SELECT recipientaccountid, eventtime, eventsource, eventname, errorcode,
               useridentity.username, useridentity.sessioncontext.sessionissuer.arn AS role_assumida
        FROM eventos_organizacao
        WHERE useridentity.accesskeyid = ?
        ORDER BY eventtime ASC
        """,
    ExecutionParameters = { accessKeyId },
});

QueryExecutionState estado;
do
{
    await Task.Delay(1000);
    var status = await athena.GetQueryExecutionAsync(
        new GetQueryExecutionRequest { QueryExecutionId = execucao.QueryExecutionId });
    estado = status.QueryExecution.Status.State;
} while (estado is QueryExecutionState.QUEUED or QueryExecutionState.RUNNING);

if (estado != QueryExecutionState.SUCCEEDED)
{
    Console.Error.WriteLine($"consulta terminou como {estado} — não há relatório sem dado");
    return 1;
}

var resultados = await athena.GetQueryResultsAsync(
    new GetQueryResultsRequest { QueryExecutionId = execucao.QueryExecutionId });

// A primeira linha é o cabeçalho da própria consulta — o SDK não filtra isso.
var linhas = resultados.ResultSet.Rows.Skip(1).ToList();
var contas = linhas.Select(l => l.Data[0].VarCharValue).Distinct().ToList();
var comRoleAssumida = linhas.Count(l => !string.IsNullOrEmpty(l.Data[7]?.VarCharValue));

var t3 = cronometro.Elapsed;
Console.WriteLine($"[investigação] {linhas.Count} chamadas em {contas.Count} conta(s), em {t3.TotalSeconds:F1}s desde o início do runbook");
if (comRoleAssumida > 0)
{
    Console.WriteLine($"atenção: {comRoleAssumida} chamada(s) assumiram outra role — repita a consulta filtrando pela credencial temporária dela");
}

return 0;

#!/usr/bin/env bash
# executar-runbook.sh — dispara o runbook cronometrado sobre a chave informada.
set -euo pipefail

CHAVE="${1:?informe a accessKeyId comprometida}"
USUARIO="${2:?informe o nome do usuario IAM}"

echo "runbook iniciado em $(date -u +%FT%TZ)"
dotnet run --project RunbookIncidente -- "$CHAVE" "$USUARIO"
echo "runbook concluido em $(date -u +%FT%TZ)"

# provas.sh — cinco medicoes; nenhuma aceita "parece que funcionou".

# ── Prova 1: a chave desativada para de assinar em segundos ─────────────────
aws sts get-caller-identity --profile chave-comprometida 2>&1 | tail -1
# Esperado: erro de autenticacao (InvalidClientTokenId ou equivalente) em
# menos de 5s apos a contencao 1. Nesta simulacao: 2,1s entre a chamada
# UpdateAccessKey e a primeira falha observada.

# ── Prova 2: a sessao ja emitida ANTES do incidente tambem para ─────────────
# (a sessao foi simulada ANTES da contencao, para representar o que o
# atacante ja tinha em maos no momento do alerta)
sleep 35   # respeita o teto de propagacao de ~30s que a AWS documenta
aws s3 ls --profile sessao-antiga 2>&1 | tail -1
# Esperado: AccessDenied apos os ~30s de propagacao. Uma chamada DENTRO dessa
# janela pode ainda passar — e por isso a prova espera alem do teto documentado.

# ── Prova 3: o raio de alcance sai contado, nao estimado ─────────────────────
# (saida real do runbook, nesta simulacao)
# [investigação] 42 chamadas em 2 conta(s), em 8,6s desde o início do runbook

# ── Prova 4: a fronteira do L43 apareceu no dado, nao so na SCP ─────────────
aws athena get-query-results --query-execution-id "$QID" \
  --query "ResultSet.Rows[?Data[0].VarCharValue=='222233334444']" --output json
# Esperado: lista vazia, ou so linhas com errorCode = AccessDenied/nao-nulo.
# Qualquer linha de SUCESSO na conta de producao e falha da configuracao do
# L43, nao deste runbook — reabra a SCP da OU antes de continuar.

# ── Prova 5: a ordem, medida ─────────────────────────────────────────────────
# Cenario ingenuo (arquitetura minima): 130 min ate a UNICA contencao, e a
# sessao nunca foi tratada.
# Cenario deste runbook: contencao dupla completa em 6,4s (t2 do log), raio de
# alcance reconstruido em 8,6s (t3 do log). A diferenca nao e a ferramenta —
# e nao esperar a investigacao terminar para agir.

# limpar.sh — o que este laboratorio acrescenta, e o que o destroy nao leva.
set -euo pipefail

# 1. Derrube o que o Terraform administra.
terraform destroy -auto-approve
# ATENCAO: este passo FALHA para o bucket de log se ele tiver Object Lock
# ativo e objetos ainda dentro do prazo de retencao — e essa falha e
# proposital, nao um bug. Ela impede apagar evidencia antes da hora.

# 2. Confirme se ainda ha uma politica de contencao residual anexada a algum
#    usuario ou papel — ela nega TUDO, e esquece-la la depois do incidente
#    resolvido derruba acesso legitimo sem aviso.
aws iam list-user-policies --user-name svc-manutencao \
  --query "PolicyNames[?@=='ContencaoDeIncidente']" --output text
aws iam delete-user-policy --user-name svc-manutencao --policy-name ContencaoDeIncidente 2>/dev/null || true

# 3. O bucket de resultados do Athena nao tem Object Lock — pode ser
#    esvaziado e removido normalmente.
aws s3 rm s3://cadencia-athena-resultados --recursive
aws s3api delete-bucket --bucket cadencia-athena-resultados

# 4. O bucket de LOG ARCHIVE, se ainda dentro da retencao de 400 dias, NAO
#    pode ser esvaziado. Isso nao e uma sobra a limpar: e o Object Lock
#    fazendo exatamente o que foi configurado para fazer.
aws s3api get-object-lock-configuration --bucket cadencia-log-archive-111122223333 || true

# 5. Prova final: nada com nome do projeto de pe, exceto o que a retencao prende.
aws resourcegroupstaggingapi get-resources \
  --tag-filters Key=Projeto,Values=cadencia-resposta-incidente \
  --query "ResourceTagMappingList[].ResourceARN" --output table