Lab 41 — Da policy `*` à policy que passa auditoria

# medir-a-superficie.sh — antes de mudar, veja exatamente o que esta concedido
aws iam list-attached-role-policies --role-name cadencia-api-task-role \
  --query 'AttachedPolicies[].PolicyName' --output table
# AdministratorAccess

VERSAO=$(aws iam get-policy --policy-arn arn:aws:iam::aws:policy/AdministratorAccess \
  --query 'Policy.DefaultVersionId' --output text)
aws iam get-policy-version --policy-arn arn:aws:iam::aws:policy/AdministratorAccess \
  --version-id "$VERSAO" --query 'PolicyVersion.Document' --output json
# {
#   "Version": "2012-10-17",
#   "Statement": [{ "Effect": "Allow", "Action": "*", "Resource": "*" }]
# }
# Uma unica statement. Action "*". Nao e "muitas permissoes" — e a UNIAO de
# toda acao de todo servico, presente ou futuro. Nao ha numero para comparar
# com "quatro acoes reais": e literalmente irrestrito, e e isso que o resto
# do laboratorio substitui.

// Saida real de `aws accessanalyzer get-generated-policy`, resumida. Note a
// diferenca entre as duas statements: a primeira tem a ACAO especifica
// encontrada no CloudTrail (informacao de nivel de acao); a segunda,
// adaptada da documentacao oficial, mostra o padrao que aparece quando um
// servico so retorna informacao de nivel de SERVICO — "isto foi tocado",
// sem dizer qual acao.
{
  "generatedPolicyResult": {
    "generatedPolicies": [{
      "policy": {
        "Version": "2012-10-17",
        "Statement": [
          {
            "Sid": "AcoesDeNivelDeAcao",
            "Effect": "Allow",
            "Action": ["secretsmanager:GetSecretValue", "sns:Publish", "sqs:SendMessage", "s3:GetObject", "s3:PutObject"],
            "Resource": "*"
            // Access Analyzer encontrou a ACAO exata no CloudTrail. Resource
            // ainda vem "*" — restringir ao ARN certo e trabalho da revisao
            // humana, nao algo que a geracao resolve sozinha.
          },
          {
            "Sid": "FullAccessToSomeServices",
            "Effect": "Allow",
            "NotAction": ["ec2:*", "iam:*", "organizations:*"],
            "Resource": "*"
            // Padrao de nivel de SERVICO (exemplo adaptado da documentacao
            // oficial): "permita tudo, exceto o que sei que voce nao usou".
            // Na pratica isto ainda e amplo — e e exatamente o statement que
            // a revisao humana precisa reescrever acao por acao.
          }
        ]
      }
    }]
  }
}

# trilha.tf — a evidencia que a geracao de policy precisa encontrar
#
# O assistente de geracao de policy pede para apontar uma TRILHA do
# CloudTrail — nao os 90 dias de Event History que toda conta AWS ja tem de
# graca. Se a Cadencia nunca configurou uma trilha, a geracao nao tem onde
# ler, e essa dependencia so aparece na hora de tentar usar a ferramenta.

resource "aws_s3_bucket" "trilha" {
  bucket = "${var.projeto}-cloudtrail-${data.aws_caller_identity.atual.account_id}"
}

resource "aws_s3_bucket_lifecycle_configuration" "trilha" {
  bucket = aws_s3_bucket.trilha.id
  rule {
    id     = "expira-em-1-ano"
    status = "Enabled"
    # O horizonte de revisao deste laboratorio e mensal; um ano de log cobre
    # qualquer investigacao retroativa razoavel sem crescer para sempre.
    expiration { days = 365 }
  }
}

resource "aws_s3_bucket_policy" "trilha" {
  bucket = aws_s3_bucket.trilha.id
  policy = data.aws_iam_policy_document.trilha_permite_cloudtrail.json
}

data "aws_iam_policy_document" "trilha_permite_cloudtrail" {
  statement {
    sid = "AWSCloudTrailWrite"
    principals {
      type        = "Service"
      identifiers = ["cloudtrail.amazonaws.com"]
    }
    actions   = ["s3:PutObject"]
    resources = ["${aws_s3_bucket.trilha.arn}/AWSLogs/${data.aws_caller_identity.atual.account_id}/*"]
    condition {
      test     = "StringEquals"
      variable = "s3:x-amz-acl"
      values   = ["bucket-owner-full-control"]
    }
  }
  statement {
    sid = "AWSCloudTrailAclCheck"
    principals {
      type        = "Service"
      identifiers = ["cloudtrail.amazonaws.com"]
    }
    actions   = ["s3:GetBucketAcl"]
    resources = [aws_s3_bucket.trilha.arn]
  }
}

resource "aws_cloudtrail" "principal" {
  name                          = "${var.projeto}-trilha"
  s3_bucket_name                = aws_s3_bucket.trilha.id
  include_global_service_events = true
  is_multi_region_trail         = false # a Cadencia opera numa unica regiao
  enable_log_file_validation    = true

  # Eventos de GERENCIAMENTO bastam para gerar a policy da task role: eles ja
  # registram qual ACAO foi chamada. Eventos de DADO (leitura/gravacao de
  # objeto S3, item do DynamoDB) cobram por evento e so valem a pena se voce
  # tambem quiser auditar QUAL objeto foi lido — fora do escopo deste laboratorio.
}

resource "aws_accessanalyzer_analyzer" "acesso_externo" {
  analyzer_name = "${var.projeto}-acesso-externo"
  type          = "ACCOUNT"
  # "Gerar policy do CloudTrail" e "achar acesso externo nao intencional" sao
  # USOS diferentes da mesma ferramenta. O analisador de acesso externo roda
  # continuamente sobre resource policy; a geracao de policy e uma chamada
  # sob demanda (start-policy-generation), sem recurso persistente equivalente.
  # Nao confundir com o analisador de ACESSO NAO UTILIZADO — outro `type`, e o L48.
}

data "aws_caller_identity" "atual" {}

#!/usr/bin/env bash
# gerar-policy.sh — a candidata vem do CloudTrail, a decisao continua sua
set -euo pipefail

ROLE_ARN="${ROLE_ARN:?defina ROLE_ARN da task role}"
TRILHA_ARN="${TRILHA_ARN:?defina TRILHA_ARN (arn do aws_cloudtrail.principal)}"
SERVICE_ROLE_ARN="${SERVICE_ROLE_ARN:?defina o service role que o Access Analyzer usa para ler a trilha}"
REGIAO="${REGIAO:-us-east-1}"

# A janela E a decisao mais importante deste script. Curta demais, a
# candidata nasce sem o job de fim de mes e sem o caminho de erro — os dois
# caminhos raros que este laboratorio existe para lembrar. 35 dias cobre um
# ciclo de fechamento mensal inteiro; ajuste ao SEU calendario de negocio.
INICIO="$(date -u -v-35d +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -d '35 days ago' +%Y-%m-%dT%H:%M:%SZ)"
FIM="$(date -u +%Y-%m-%dT%H:%M:%SZ)"

JOB_ID=$(aws accessanalyzer start-policy-generation \
  --policy-generation-details "principalArn=${ROLE_ARN}" \
  --cloud-trail-details "trails=[{cloudTrailArn=${TRILHA_ARN},region=${REGIAO},allRegions=false}],accessRole=${SERVICE_ROLE_ARN},startTime=${INICIO},endTime=${FIM}" \
  --query 'jobId' --output text)

echo "geracao iniciada: ${JOB_ID}"

# A geracao roda em segundo plano. Nao existe webhook: espere e consulte.
STATUS="IN_PROGRESS"
while [ "$STATUS" = "IN_PROGRESS" ]; do
  sleep 15
  STATUS=$(aws accessanalyzer get-generated-policy --job-id "$JOB_ID" \
    --query 'jobDetails.status' --output text)
  echo "status: ${STATUS}"
done

if [ "$STATUS" != "SUCCEEDED" ]; then
  echo "geracao terminou como ${STATUS} — leia jobDetails.jobError antes de repetir" >&2
  exit 1
fi

# Duas categorias de retorno: para alguns servicos vem a ACAO exata
# encontrada no CloudTrail; para outros, so o SERVICO que foi tocado, com um
# NotAction que na pratica ainda concede quase tudo dele. Isto NAO e a
# policy final — e o rascunho que a revisao humana estreita.
aws accessanalyzer get-generated-policy --job-id "$JOB_ID" \
  --include-resource-placeholders --include-service-level-template \
  --query 'generatedPolicyResult.generatedPolicies[0].policy' --output text \
  > candidata.json

echo "candidata em candidata.json — REVISE antes de qualquer aws iam create-policy"

# O validador pega erro de sintaxe e sugestao de seguranca, mas nao decide
# por voce se uma acao vista uma unica vez merece virar permissao permanente.
aws accessanalyzer validate-policy \
  --policy-document "file://candidata.json" \
  --policy-type IDENTITY_POLICY \
  --query 'findings[].{tipo:findingType,msg:findingDetails}' --output table

// PedidoService.cs — os quatro caminhos reais, e a acao IAM que cada um pede
//
// Isto nao e uma classe nova: sao os metodos que ja existiam no L01/L03, e
// que a geracao de policy vai encontrar no CloudTrail. Ler o codigo e o
// segundo jeito de saber o que a task role precisa — a evidencia do
// CloudTrail e o primeiro, e os dois devem concordar.

public class PedidoService
{
    private readonly IAmazonS3 _s3;
    private readonly IAmazonSQS _sqs;
    private readonly IAmazonSecretsManager _secrets;
    private readonly IAmazonSimpleNotificationService _sns;
    private string? _chaveGatewayCache;

    // Caminho do dia a dia (1 de 4): grava a nota fiscal. Precisa de
    // s3:PutObject sobre o prefixo notas-fiscais/ do bucket.
    public async Task UploadNotaFiscalAsync(Guid pedidoId, Stream pdf)
    {
        await _s3.PutObjectAsync(new PutObjectRequest
        {
            BucketName  = "cadencia-documentos",
            Key         = $"notas-fiscais/{pedidoId}.pdf",
            InputStream = pdf,
        });
    }

    // Caminho do dia a dia (2 de 4): enfileira para o fulfillment. Precisa de
    // sqs:SendMessage sobre a fila cadencia-fulfillment.
    public async Task EnfileirarFulfillmentAsync(Guid pedidoId)
    {
        await _sqs.SendMessageAsync(new SendMessageRequest
        {
            QueueUrl    = _filaFulfillmentUrl,
            MessageBody = JsonSerializer.Serialize(new { pedidoId }),
        });
    }

    // Startup e a cada 12h: le a chave do gateway de pagamento. Precisa de
    // secretsmanager:GetSecretValue sobre ESTE segredo — nao o do banco, que
    // e injetado pelo execution role via `secrets` na task definition (L03).
    public async Task<string> ObterChaveGatewayAsync()
    {
        if (_chaveGatewayCache is not null) return _chaveGatewayCache;
        var resp = await _secrets.GetSecretValueAsync(new GetSecretValueRequest
        {
            SecretId = "cadencia/gateway-pagamento",
        });
        _chaveGatewayCache = resp.SecretString;
        return _chaveGatewayCache;
    }

    // Caminho RARO (3 de 4): so executa quando o pagamento falha. Se a janela
    // de observacao do CloudTrail nunca incluiu um dia de erro, esta acao nao
    // aparece na policy candidata — e o primeiro erro real em producao falha
    // ao tentar avisar alguem, exatamente quando o alerta mais importa.
    public async Task PublicarAlertaErroAsync(Guid pedidoId, string motivo)
    {
        await _sns.PublishAsync(new PublishRequest
        {
            TopicArn = _topicoAlertasArn,
            Message  = $"Falha no pedido {pedidoId}: {motivo}",
        });
    }

    // Job mensal (RARO, 4 de 4): mesmo bucket, prefixo diferente. Ja coberto
    // pelo s3:PutObject acima, porque a policy final restringe por BUCKET,
    // nao por prefixo — decisao registrada na secao de decisoes.
    public async Task GerarRelatorioMensalAsync(Stream relatorio)
    {
        await _s3.PutObjectAsync(new PutObjectRequest
        {
            BucketName  = "cadencia-documentos",
            Key         = $"relatorios-mensais/{DateOnly.FromDateTime(DateTime.UtcNow):yyyy-MM}.csv",
            InputStream = relatorio,
        });
    }
}

# task-role-final.tf — a policy candidata, revisada, com Resource restrito
#
# Compare com a arquitetura minima: la era um managed policy da AWS
# (AdministratorAccess) anexado direto. Aqui sao quatro acoes, cada uma com
# Resource especifico — nenhum "*" sobrou, porque as quatro suportam ARN de
# recurso. Isso nem sempre e verdade (o ecr:GetAuthorizationToken do L03 nao
# suporta), mas aqui e, e por isso a policy final nao precisa de nenhuma
# frase de justificativa de wildcard.

data "aws_iam_policy_document" "task_role_final" {
  statement {
    sid       = "NotasFiscaisEDadosMensais"
    actions   = ["s3:GetObject", "s3:PutObject"]
    resources = ["${aws_s3_bucket.documentos.arn}/notas-fiscais/*",
                 "${aws_s3_bucket.documentos.arn}/relatorios-mensais/*"]
    # Restringir por PREFIXO em vez de por bucket inteiro seria o proximo
    # refinamento, feito aqui com `Resource`, nao com `Condition`. Uma
    # condicao por tag de recurso, IP de origem ou hora do dia fica fora do
    # escopo deste laboratorio — e o passo seguinte, nao o entregavel dele.
  }
  statement {
    sid       = "FilaDeFulfillment"
    actions   = ["sqs:SendMessage"]
    resources = [aws_sqs_queue.fulfillment.arn]
  }
  statement {
    sid       = "SegredoDoGateway"
    actions   = ["secretsmanager:GetSecretValue"]
    resources = [aws_secretsmanager_secret.gateway.arn]
  }
  statement {
    sid       = "AlertaDeErro"
    actions   = ["sns:Publish"]
    resources = [aws_sns_topic.alertas_erro.arn]
  }
}

resource "aws_iam_policy" "task_role_final" {
  name   = "${var.projeto}-task-role-derivada"
  policy = data.aws_iam_policy_document.task_role_final.json
}

# O limite de permissao (permissions boundary): um TETO, nao uma concessao.
# Mesmo que alguem anexe amanha uma policy mais ampla "para nao travar de
# novo", o boundary impede que ela valha alem dos servicos aqui listados. Ele
# NAO SUBSTITUI a policy estreita — as duas juntas fecham o cerco: a policy
# diz o que E permitido hoje; o boundary diz o que NUNCA pode ser permitido,
# mesmo por engano futuro.
data "aws_iam_policy_document" "limite_de_permissao" {
  statement {
    actions   = ["s3:*", "sqs:*", "secretsmanager:GetSecretValue", "sns:Publish"]
    resources = ["*"]
    # O boundary pode ser mais largo que a policy do dia (aqui usa s3:* e
    # sqs:*, nao as acoes exatas) porque ele e o TETO de mudancas futuras, nao
    # a permissao do dia a dia — essa quem restringe e a policy acima. Um
    # boundary tao apertado quanto a policy atual quebraria a primeira
    # mudanca legitima de escopo do produto.
  }
}

resource "aws_iam_policy" "limite_de_permissao" {
  name   = "${var.projeto}-limite-task-role"
  policy = data.aws_iam_policy_document.limite_de_permissao.json
}

resource "aws_iam_role" "task_final" {
  name                  = "${var.projeto}-task-role"
  permissions_boundary  = aws_iam_policy.limite_de_permissao.arn
  assume_role_policy    = data.aws_iam_policy_document.task_assume.json
}

resource "aws_iam_role_policy_attachment" "task_final" {
  role       = aws_iam_role.task_final.name
  policy_arn = aws_iam_policy.task_role_final.arn
}

# A troca em si: aponte a task definition do L03 para esta role e reaplique.
# Nenhum outro campo da task definition muda — mesma imagem, mesmo servico,
# so a identidade que ele assume fica mais estreita.

# provas.sh — cinco medicoes; nenhuma conclusao vem de "parece que funcionou"

PROJETO=cadencia; REGIAO=us-east-1

# ── Prova 1: a candidata gerada contem exatamente os servicos esperados ──────
aws accessanalyzer get-generated-policy --job-id "$JOB_ID" \
  --query 'generatedPolicyResult.generatedPolicies[0].policy.Statement[].Action' \
  --output json
# Esperado: secretsmanager, sns, sqs e s3 aparecem. Se sns estiver ausente, a
# janela de observacao nao capturou nenhum erro — volte e amplie o periodo,
# ou force o caminho de erro antes de gerar de novo.

# ── Prova 2: zero AccessDenied durante o teste completo em staging ───────────
aws logs filter-log-events --log-group-name "/ecs/${PROJETO}-api-staging" \
  --filter-pattern "AccessDenied" --query 'events[].message' --output text
# Esperado: saida vazia. Qualquer linha aqui e uma acao que a policy candidata
# nao cobre — identifique-a e volte para a revisao antes de promover.

# ── Prova 3: o caminho de erro foi de fato exercitado no teste ───────────────
aws cloudtrail lookup-events --lookup-attributes \
  AttributeKey=EventName,AttributeValue=Publish \
  --start-time "$(date -u -v-1H +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -d '1 hour ago' +%Y-%m-%dT%H:%M:%SZ)" \
  --query 'Events[].EventName' --output text
# Esperado: pelo menos um "Publish". Se vazio, o teste de staging nao forcou
# o pagamento recusado, e a prova 2 nao provou o que precisa provar.

# ── Prova 4: producao roda 24h sem AccessDenied depois da promocao ───────────
aws logs filter-log-events --log-group-name "/ecs/${PROJETO}-api" \
  --filter-pattern "AccessDenied" \
  --start-time "$(date -u -v-24H +%s000 2>/dev/null || date -u -d '24 hours ago' +%s000)" \
  --query 'events[].message' --output text
# Esperado: saida vazia. Diferente da prova 2 (staging, teste dirigido), esta
# e producao com trafego real — e o criterio de aceite do laboratorio.

# ── Prova 5: nenhum achado ativo de acesso externo nos recursos tocados ──────
aws accessanalyzer list-findings-v2 --analyzer-arn "$ANALISADOR_ARN" \
  --filter '{"status":{"eq":["ACTIVE"]}}' \
  --query 'findings[].{recurso:resource,tipo:findingType}' --output table
# Esperado: tabela vazia para o bucket e o segredo deste laboratorio. Um
# achado ativo significa resource policy permitindo principal fora da conta,
# independente de a role da task ter sido estreitada.

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

# 2. VERSOES DA POLICY: o IAM guarda ate 5 versoes por policy gerenciada pelo
#    cliente. O destroy remove a policy inteira, mas se voce for reaproveitar o
#    nome, versoes antigas atrapalham a criacao de versao nova.
aws iam list-policy-versions --policy-arn "$POLICY_ARN" \
  --query "Versions[?IsDefaultVersion==\`false\`].VersionId" --output text

# 3. BUCKET DA TRILHA: tem retencao propria (lifecycle de 1 ano) e nao pertence
#    ao ciclo do laboratorio. Precisa estar vazio antes do delete.
aws s3 rm "s3://${PROJETO}-cloudtrail-${CONTA}" --recursive
aws s3api delete-bucket --bucket "${PROJETO}-cloudtrail-${CONTA}"

# 4. ANALISADOR DE ACESSO EXTERNO: nao cobra parado, mas continua avaliando
#    recursos que talvez ja nao existam mais no seu ambiente de teste.
aws accessanalyzer delete-analyzer --analyzer-name "${PROJETO}-acesso-externo"

# 5. JOBS DE GERACAO DE POLICY: nao sao recurso persistente, mas o candidata.json
#    local pode conter Resource com ARN da sua conta — nao deixe em repositorio publico.
rm -f candidata.json

# 6. CUIDADO: NAO apague a trilha de CloudTrail "de verdade" da conta se ela
#    ja existia antes deste laboratorio. O script acima assume uma trilha CRIADA
#    para o laboratorio; remover a trilha de producao da organizacao e outro raio
#    de explosao completamente diferente.

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