Lab 46 — Criptografia: KMS, envelope, CMK e rotação

{
  "eventSource": "kms.amazonaws.com",
  "eventName": "GenerateDataKey",
  "awsRegion": "us-east-1",
  "userIdentity": {
    "type": "AWSService",
    "invokedBy": "s3.amazonaws.com"
  },
  "requestParameters": {
    "keyId": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-clientes",
    "keySpec": "AES_256",
    "encryptionContext": {
      "aws:s3:arn": "arn:aws:s3:::ffv-lab-notas-fiscais/2026/08/nf-000123.pdf"
    }
  },
  "responseElements": null
}

# kms.tf — duas CMKs, uma por classe de dado, com politica propria

# ── CMK 1: dado de cliente (RDS + o segredo que abre o banco) ────────────────
resource "aws_kms_key" "clientes" {
  description = "Cadencia — dado de cliente: RDS de pedidos e o segredo do Postgres"

  # Janela de espera antes da exclusao FINAL, se um dia a chave for agendada
  # para exclusao. Enquanto a janela corre, a operacao e CANCELAVEL; depois
  # dela, nao. Ver a secao de Seguranca sobre por que isto e o unico risco
  # verdadeiramente irreversivel deste laboratorio.
  deletion_window_in_days = 30

  # Rotacao automatica, periodo padrao de 365 dias a partir de quando foi
  # HABILITADA (nao da criacao da chave). NAO VERIFICADO nesta versao do
  # provider: se `rotation_period_in_days` esta disponivel no seu provider
  # para customizar o periodo, confira a documentacao do provider antes de
  # usar — aqui fica no padrao.
  enable_key_rotation = true

  policy = data.aws_iam_policy_document.chave_clientes.json
  tags   = var.tags
}

resource "aws_kms_alias" "clientes" {
  name          = "alias/${var.projeto}-clientes"
  target_key_id = aws_kms_key.clientes.key_id
}

# A politica e um documento SEPARADO da politica IAM de quem usa a chave — os
# dois precisam concordar (interseccao, nao uniao), mesma logica de SCP+IAM do
# L43. Omitir o principal raiz da conta e o erro que mais custa: sem ele, uma
# politica escrita errado pode tirar de TODO MUNDO — inclusive de quem
# administra a conta — a capacidade de corrigir a propria politica da chave.
data "aws_iam_policy_document" "chave_clientes" {
  statement {
    sid       = "PermiteAContaRaizAdministrarComoUltimoRecurso"
    effect    = "Allow"
    actions   = ["kms:*"]
    resources = ["*"]
    principals {
      type        = "AWS"
      identifiers = ["arn:aws:iam::${data.aws_caller_identity.atual.account_id}:root"]
    }
    # "kms:*" e "*" aqui SO se justificam porque o principal e a conta raiz e
    # o efeito e a rede de seguranca contra lockout — nao e o padrao de acesso
    # do dia a dia, que vem nos statements abaixo, restritos por proposito.
  }

  statement {
    sid       = "PermiteAdministradoresDeChaveGerenciarem"
    effect    = "Allow"
    actions = [
      "kms:Create*", "kms:Describe*", "kms:Enable*", "kms:List*",
      "kms:Put*", "kms:Update*", "kms:Revoke*", "kms:Disable*",
      "kms:Get*", "kms:Delete*", "kms:TagResource", "kms:UntagResource",
      "kms:ScheduleKeyDeletion", "kms:CancelKeyDeletion", "kms:CreateGrant",
    ]
    resources = ["*"]
    principals {
      type        = "AWS"
      identifiers = [var.role_administrador_arn]
    }
    # CreateGrant entra aqui porque e o principal do PIPELINE (quem roda o
    # terraform apply) quem precisa dele: e essa identidade que chama
    # CreateDBInstance, e o RDS usa a permissao de QUEM CHAMOU para criar a
    # concessao automatica que ele mesmo vai usar depois. A task role da
    # aplicacao nunca chama kms:CreateGrant.
  }

  statement {
    sid       = "PermiteTaskRoleUsarViaSecretsManager"
    effect    = "Allow"
    actions   = ["kms:Decrypt", "kms:DescribeKey"]
    resources = ["*"]
    principals {
      type        = "AWS"
      identifiers = [aws_iam_role.task.arn]
    }
    condition {
      test     = "StringEquals"
      variable = "kms:ViaService"
      values   = ["secretsmanager.${var.regiao}.amazonaws.com"]
    }
    # Esta e a trava que a chave gerenciada pela AWS nunca teve: o principal e
    # NOMEADO (o ARN da task role, nao "qualquer um que a IAM deixar"), e o
    # uso e restrito a UM servico. Chamar kms:Decrypt fora do Secrets Manager
    # com a mesma credencial e negado por esta politica, mesmo que a IAM do
    # principal permita a acao.
  }
}

# ── CMK 2: documentos fiscais (S3) — classe de dado diferente ────────────────
resource "aws_kms_key" "documentos" {
  description              = "Cadencia — documentos fiscais em PDF no S3"
  deletion_window_in_days  = 30
  enable_key_rotation      = true
  policy                   = data.aws_iam_policy_document.chave_documentos.json
  tags                     = var.tags
}

resource "aws_kms_alias" "documentos" {
  name          = "alias/${var.projeto}-documentos"
  target_key_id = aws_kms_key.documentos.key_id
}

data "aws_iam_policy_document" "chave_documentos" {
  statement {
    sid       = "PermiteAContaRaizAdministrarComoUltimoRecurso"
    effect    = "Allow"
    actions   = ["kms:*"]
    resources = ["*"]
    principals {
      type        = "AWS"
      identifiers = ["arn:aws:iam::${data.aws_caller_identity.atual.account_id}:root"]
    }
  }

  statement {
    sid       = "PermiteTaskRoleGravarELerViaS3"
    effect    = "Allow"
    actions   = ["kms:GenerateDataKey", "kms:Decrypt", "kms:DescribeKey"]
    resources = ["*"]
    principals {
      type        = "AWS"
      identifiers = [aws_iam_role.task.arn]
    }
    condition {
      test     = "StringEquals"
      variable = "kms:ViaService"
      values   = ["s3.${var.regiao}.amazonaws.com"]
    }
    # GenerateDataKey entra porque quem GRAVA precisa pedir a chave de dados;
    # Decrypt entra porque quem LE precisa decifra-la de volta. Omitir
    # GenerateDataKey e o defeito mais comum desta politica — ver a secao de
    # "Quebrar de proposito".
  }
}

data "aws_caller_identity" "atual" {}

# rds.tf e segredo.tf — apontando para a CMK de clientes, nao mais para aws/rds

resource "aws_db_instance" "principal" {
  identifier     = "${var.projeto}-pedidos"
  engine         = "postgres"
  engine_version = "16"
  instance_class = "db.t4g.medium"

  # Antes deste laboratorio: sem `kms_key_id`, o RDS usava `aws/rds`. A unica
  # mudanca de configuracao no recurso do banco em si e esta linha — o resto
  # do controle de acesso vive na POLITICA da chave, nao aqui.
  storage_encrypted = true
  kms_key_id         = aws_kms_key.clientes.arn

  db_name  = "cadencia"
  username = "app_admin"
  # A senha inicial NAO fica em variavel nem em environment: o Secrets
  # Manager gera e guarda, e o segredo abaixo referencia este banco.
  manage_master_user_password   = false
  password                      = random_password.senha_inicial.result

  db_subnet_group_name   = aws_db_subnet_group.principal.name
  vpc_security_group_ids = [aws_security_group.db.id]

  skip_final_snapshot       = false
  final_snapshot_identifier = "${var.projeto}-pedidos-final"
  # O snapshot final HERDA a criptografia do banco de origem — continua sob a
  # cmk_clientes, e continua contando para a fatura depois do destroy. Ver a
  # secao de Limpeza.

  tags = var.tags
}

resource "random_password" "senha_inicial" {
  length  = 32
  special = false # o driver do Postgres deste laboratorio nao escapa alguns especiais
}

# O segredo do L04, agora explicitamente sob a CMK de clientes em vez da
# chave gerenciada padrao. E o mesmo objeto, so a chave que o protege mudou.
resource "aws_secretsmanager_secret" "banco" {
  name       = "${var.projeto}/banco/app-rw"
  kms_key_id = aws_kms_key.clientes.arn
  tags       = var.tags
}

resource "aws_secretsmanager_secret_version" "banco" {
  secret_id = aws_secretsmanager_secret.banco.id
  secret_string = jsonencode({
    host     = aws_db_instance.principal.address
    port     = 5432
    dbname   = aws_db_instance.principal.db_name
    username = aws_db_instance.principal.username
    password = random_password.senha_inicial.result
  })
}

# s3.tf — SSE-KMS com a CMK de documentos, e Bucket Keys ligado

resource "aws_s3_bucket" "notas_fiscais" {
  bucket = "${var.projeto}-notas-fiscais-${data.aws_caller_identity.atual.account_id}"
  tags   = var.tags
}

resource "aws_s3_bucket_server_side_encryption_configuration" "notas_fiscais" {
  bucket = aws_s3_bucket.notas_fiscais.id

  rule {
    apply_server_side_encryption_by_default {
      sse_algorithm     = "aws:kms"
      kms_master_key_id = aws_kms_key.documentos.arn
    }
    # Bucket Keys: o S3 gera UMA chave de dados por bucket (renovada
    # periodicamente) em vez de uma por objeto, e a reusa para varios
    # PutObject/GetObject. Isso corta a maior parte das chamadas ao KMS —
    # e e a linha que mais separa "poucos reais" de "linha visivel na
    # fatura" em alta escala. Ver Custo.
    bucket_key_enabled = true
  }
}

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

# Recusa qualquer PutObject que nao declare SSE-KMS com ESTA chave. Sem esta
# politica, um upload sem cabecalho de criptografia caberia na configuracao
# "por padrao" mesmo assim — mas um cliente que envia SSE-S3 explicitamente,
# ou outra CMK, passaria por cima da intencao deste bucket.
data "aws_iam_policy_document" "bucket_notas_fiscais" {
  statement {
    sid    = "NegaUploadForaDaCmkDeDocumentos"
    effect = "Deny"
    principals {
      type        = "*"
      identifiers = ["*"]
    }
    actions   = ["s3:PutObject"]
    resources = ["${aws_s3_bucket.notas_fiscais.arn}/*"]
    condition {
      test     = "StringNotEquals"
      variable = "s3:x-amz-server-side-encryption-aws-kms-key-id"
      values   = [aws_kms_key.documentos.arn]
    }
  }
}

resource "aws_s3_bucket_policy" "notas_fiscais" {
  bucket = aws_s3_bucket.notas_fiscais.id
  policy = data.aws_iam_policy_document.bucket_notas_fiscais.json
}

// CifraDeCampo.cs — envelope explicito para o CPF, alem da cifra do volume do RDS
//
// A criptografia de armazenamento do RDS e transparente para qualquer conexao
// AUTENTICADA: uma credencial valida — vazada, ou usada por uma injecao de SQL
// bem sucedida — recebe o CPF em texto claro, porque a decifragem ja aconteceu
// antes de o Postgres processar a consulta. Esta classe fecha ESSE gap
// especifico: mesmo com a credencial do banco, quem le a linha sem a CMK de
// clientes nao decifra o campo.

using Amazon.KeyManagementService;
using Amazon.KeyManagementService.Model;
using System.Security.Cryptography;

public sealed class CifraDeCampoCliente
{
    private readonly IAmazonKeyManagementService _kms;
    private readonly string _cmkClientesArn;

    public CifraDeCampoCliente(IAmazonKeyManagementService kms, string cmkClientesArn)
    {
        _kms = kms;
        _cmkClientesArn = cmkClientesArn;
    }

    // O contexto de cifragem amarra o ciphertext ao REGISTRO. Sem ele, um
    // ciphertext de CPF trocado entre duas linhas da mesma tabela decifraria
    // sem erro nenhum — o KMS nao tem como saber que aquele valor pertence a
    // outro cliente. Com contexto, decifrar com o ID errado falha alto.
    private static Dictionary<string, string> ContextoDoRegistro(Guid clienteId) => new()
    {
        ["cliente_id"] = clienteId.ToString(),
        ["campo"] = "cpf",
    };

    public async Task<byte[]> CifrarAsync(Guid clienteId, string cpfEmClaro)
    {
        // Uma chave de dados NOVA por operacao — nunca reaproveitada entre
        // registros. E a mesma logica de "uma vez, ou poucas vezes" que
        // justifica a rotacao da propria CMK, aplicada aqui ao nivel do campo.
        var dataKey = await _kms.GenerateDataKeyAsync(new GenerateDataKeyRequest
        {
            KeyId = _cmkClientesArn,
            KeySpec = DataKeySpec.AES_256,
            EncryptionContext = ContextoDoRegistro(clienteId),
        });

        using var aes = new AesGcm(dataKey.Plaintext.ToArray(), AesGcm.TagByteSizes.MaxSize);
        var nonce = RandomNumberGenerator.GetBytes(AesGcm.NonceByteSizes.MaxSize);
        var textoClaro = System.Text.Encoding.UTF8.GetBytes(cpfEmClaro);
        var ciphertext = new byte[textoClaro.Length];
        var tag = new byte[AesGcm.TagByteSizes.MaxSize];
        aes.Encrypt(nonce, textoClaro, ciphertext, tag);

        // A copia em texto claro da chave de dados so existe ate aqui. Ela
        // NUNCA e logada, nunca e persistida — so a copia CIFRADA (o
        // CiphertextBlob) segue para o banco, ao lado do CPF cifrado.
        Array.Clear(dataKey.Plaintext.ToArray());

        // Formato gravado: [tamanho do blob da CMK][blob][nonce][tag][ciphertext].
        // Cada linha carrega sua PROPRIA copia cifrada da chave de dados — nao
        // ha uma chave de dados global para "o campo CPF" da tabela inteira.
        using var saida = new MemoryStream();
        using var w = new BinaryWriter(saida);
        w.Write(dataKey.CiphertextBlob.ToArray().Length);
        w.Write(dataKey.CiphertextBlob.ToArray());
        w.Write(nonce);
        w.Write(tag);
        w.Write(ciphertext);
        return saida.ToArray();
    }

    public async Task<string> DecifrarAsync(Guid clienteId, byte[] registroCifrado)
    {
        using var leitor = new BinaryReader(new MemoryStream(registroCifrado));
        var tamanhoBlob = leitor.ReadInt32();
        var blob = leitor.ReadBytes(tamanhoBlob);
        var nonce = leitor.ReadBytes(AesGcm.NonceByteSizes.MaxSize);
        var tag = leitor.ReadBytes(AesGcm.TagByteSizes.MaxSize);
        var ciphertext = leitor.ReadBytes((int)(leitor.BaseStream.Length - leitor.BaseStream.Position));

        // O contexto informado aqui tem de ser IDENTICO ao usado na cifragem.
        // Se o clienteId nao bate com o registro (linha errada, migracao que
        // moveu o valor), o KMS recusa decifrar — e essa recusa e a prova de
        // que o contexto realmente amarra o dado ao dono certo.
        DecryptResponse chaveDeDados;
        try
        {
            chaveDeDados = await _kms.DecryptAsync(new DecryptRequest
            {
                CiphertextBlob = new MemoryStream(blob),
                EncryptionContext = ContextoDoRegistro(clienteId),
            });
        }
        catch (InvalidCiphertextException)
        {
            throw new InvalidOperationException(
                "contexto de cifragem nao confere: o registro pode pertencer a outro cliente");
        }

        using var aes = new AesGcm(chaveDeDados.Plaintext.ToArray(), AesGcm.TagByteSizes.MaxSize);
        var textoClaro = new byte[ciphertext.Length];
        aes.Decrypt(nonce, ciphertext, tag, textoClaro);
        Array.Clear(chaveDeDados.Plaintext.ToArray());

        return System.Text.Encoding.UTF8.GetString(textoClaro);
    }
}

#!/usr/bin/env bash
set -euo pipefail

PROJETO="${PROJETO:?defina PROJETO}"
REGIAO="${REGIAO:-us-east-1}"

terraform init -input=false
terraform apply -auto-approve

CMK_CLIENTES=$(terraform output -raw cmk_clientes_arn)
CMK_DOCUMENTOS=$(terraform output -raw cmk_documentos_arn)
echo "CMK de clientes: ${CMK_CLIENTES}"
echo "CMK de documentos: ${CMK_DOCUMENTOS}"

# Prova adicional: a trilha filtra por chave, isoladamente.
aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=EventName,AttributeValue=Decrypt \
  --max-results 10 \
  --query "Events[?contains(CloudTrailEvent, '$CMK_CLIENTES')].CloudTrailEvent" \
  --output text | python3 -m json.tool
# Esperado: todo evento retornado tem userIdentity apontando para a task role da
# Cadencia — nenhum outro principal aparece, porque a politica so autoriza este.

#!/usr/bin/env bash
set -euo pipefail

# Esvazie o bucket ANTES do destroy — objeto cifrado com SSE-KMS nao impede o
# terraform destroy no bucket, mas um bucket nao vazio, sem force_destroy, faz o
# destroy falhar na hora errada, no meio de uma cadeia de dependencias.
aws s3 rm "s3://$(terraform output -raw bucket_notas_fiscais)" --recursive

terraform destroy -auto-approve

# As duas CMKs NAO desaparecem aqui — elas entram em exclusao AGENDADA, com a
# janela de deletion_window_in_days. Confirme:
aws kms list-keys --query "Keys[].KeyId" --output text | while read -r k; do
  aws kms describe-key --key-id "$k" \
    --query "KeyMetadata.[KeyId,KeyState,DeletionDate]" --output text
done | grep PendingDeletion || echo "nenhuma chave pendente de exclusao"