Contas, roles e buckets são placeholders.

O cenário

A role <app>-backend-role na conta <ACCOUNT_ID> tem AdministratorAccess "temporariamente" há dois anos. Ninguém sabe exatamente o que a aplicação precisa, e ninguém quer ser o responsável por quebrar produção tirando permissão.

Esse é o padrão em quase toda conta que eu audito. E é exatamente o tipo de coisa que transforma um incidente pequeno (uma credencial exposta) num incidente enorme (a conta inteira comprometida).

O IAM Access Analyzer tem três recursos que resolvem isso sem chute:

  1. Último acesso por serviço: o que a role usou e quando.
  2. Geração de policy: monta uma policy com base no que a role realmente fez, lendo o CloudTrail.
  3. Validação de policy: aponta erros e permissões perigosas antes de você aplicar.

Variáveis

export AWS_PROFILE="<PERFIL_ADMIN>" export ACCOUNT_ID="<ACCOUNT_ID>" export ROLE_NAME="<app>-backend-role" export ROLE_ARN="arn:aws:iam::${ACCOUNT_ID}:role/${ROLE_NAME}" 

Passo 1: o que a role usou de verdade

JOB_ID=$(aws iam generate-service-last-accessed-details \ --arn "$ROLE_ARN" --granularity ACTION_LEVEL \ --query JobId --output text) sleep 10 aws iam get-service-last-accessed-details --job-id "$JOB_ID" --output json \ | jq -r '.ServicesLastAccessed[] | select(.LastAuthenticated != null) | [.ServiceNamespace, .LastAuthenticated, (.TotalAuthenticatedEntities | tostring)] | @tsv' | sort 

Isso já costuma assustar: de mais de 400 serviços liberados, a aplicação usa 5 ou 6.

Para listar os serviços nunca usados (os candidatos óbvios a sair):

aws iam get-service-last-accessed-details --job-id "$JOB_ID" --output json \ | jq -r '.ServicesLastAccessed[] | select(.LastAuthenticated == null) | .ServiceNamespace' \ | wc -l 

Passo 2: gerar a policy a partir do CloudTrail

O Access Analyzer lê a trilha e monta uma policy com as ações que a role chamou num período. Ele precisa de uma role de serviço com permissão de ler o bucket da trilha.

Trust policy da role de serviço (trust-access-analyzer.json):

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "access-analyzer.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } 

Permissões dela (perm-access-analyzer.json):

{ "Version": "2012-10-17", "Statement": [ { "Sid": "LerTrilha", "Effect": "Allow", "Action": [ "cloudtrail:GetTrail", "iam:GetRole", "iam:GetServiceLastAccessedDetails", "iam:GenerateServiceLastAccessedDetails" ], "Resource": "*" }, { "Sid": "LerBucketDaTrilha", "Effect": "Allow", "Action": ["s3:GetObject", "s3:ListBucket"], "Resource": [ "arn:aws:s3:::<BUCKET_CLOUDTRAIL>", "arn:aws:s3:::<BUCKET_CLOUDTRAIL>/*" ] } ] } 
aws iam create-role --role-name AccessAnalyzerPolicyGeneration \ --assume-role-policy-document file://trust-access-analyzer.json aws iam put-role-policy --role-name AccessAnalyzerPolicyGeneration \ --policy-name LerTrilha \ --policy-document file://perm-access-analyzer.json 

Se a trilha usa KMS, inclua kms:Decrypt na chave da trilha para essa role.

Agora dispare a geração para os últimos 90 dias:

INICIO="$(date -u -d '-90 days' +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -v-90d +%Y-%m-%dT%H:%M:%SZ)" FIM="$(date -u +%Y-%m-%dT%H:%M:%SZ)" cat > /tmp/trail-details.json <<EOF { "trails": [ { "cloudTrailArn": "arn:aws:cloudtrail:<REGIAO>:${ACCOUNT_ID}:trail/<NOME_DA_TRILHA>", "allRegions": true } ], "accessRole": "arn:aws:iam::${ACCOUNT_ID}:role/AccessAnalyzerPolicyGeneration", "startTime": "${INICIO}", "endTime": "${FIM}" } EOF GEN_ID=$(aws accessanalyzer start-policy-generation \ --policy-generation-details "principalArn=${ROLE_ARN}" \ --cloud-trail-details file:///tmp/trail-details.json \ --query jobId --output text) echo "$GEN_ID" 

O primeiro date é a sintaxe do Linux e o segundo a do macOS. Um dos dois funciona.

A geração leva alguns minutos. Acompanhe e baixe o resultado:

aws accessanalyzer get-generated-policy --job-id "$GEN_ID" \ --query jobDetails.status --output text aws accessanalyzer get-generated-policy --job-id "$GEN_ID" \ --include-resource-placeholders \ --query 'generatedPolicyResult.generatedPolicies[0].policy' --output text \ | jq . > policy-gerada.json 

O --include-resource-placeholders coloca marcadores como ${BucketName} onde ele não conseguiu inferir o recurso. Substitua pelos ARNs reais. Policy com "Resource": "*" em ação de escrita não é menor privilégio.

Passo 3: validar antes de aplicar

aws accessanalyzer validate-policy \ --policy-type IDENTITY_POLICY \ --policy-document file://policy-gerada.json \ --query 'findings[].[findingType,issueCode,findingDetails]' --output table 

Os findingType vêm em quatro níveis: ERROR, SECURITY_WARNING, WARNING e SUGGESTION. Só aplique com zero ERROR e zero SECURITY_WARNING.

E um recurso que pouca gente usa: checar se a nova policy não concede nada além da antiga. Útil pra provar pro time que você só está tirando permissão:

aws iam get-role-policy --role-name "$ROLE_NAME" --policy-name "<POLICY_ATUAL>" \ --query PolicyDocument --output json > policy-atual.json aws accessanalyzer check-no-new-access \ --policy-type IDENTITY_POLICY \ --new-policy-document file://policy-gerada.json \ --existing-policy-document file://policy-atual.json \ --query '[result,message]' --output text 

Resultado PASS significa que a nova é um subconjunto da antiga.

Passo 4: trocar sem quebrar produção

Não troque de uma vez. O caminho seguro:

  1. Anexe a nova policy junto com a antiga. Nada muda, porque a antiga ainda libera tudo.
  2. Teste em homologação removendo a antiga lá primeiro.
  3. Em produção, remova a antiga numa janela, com o time da aplicação acompanhando.
  4. Monitore AccessDenied da role nas horas seguintes (query 3 do post de CloudTrail no Athena).
aws iam put-role-policy --role-name "$ROLE_NAME" \ --policy-name "${ROLE_NAME}-menor-privilegio" \ --policy-document file://policy-gerada.json # Depois de validado: aws iam detach-role-policy --role-name "$ROLE_NAME" \ --policy-arn arn:aws:iam::aws:policy/AdministratorAccess 

Plano de volta, caso algo quebre: é só anexar a AdministratorAccess de novo. Em segundos a aplicação volta. Deixe esse comando pronto no runbook da mudança.

Fazendo isso em escala

Para achar as piores roles da conta de uma vez, liste quem tem AdministratorAccess anexada:

aws iam list-entities-for-policy \ --policy-arn arn:aws:iam::aws:policy/AdministratorAccess \ --query '{roles: PolicyRoles[].RoleName, usuarios: PolicyUsers[].UserName, grupos: PolicyGroups[].GroupName}' \ --output json 

E ligue o analisador de acesso não utilizado, que aponta continuamente roles, chaves e permissões paradas:

aws accessanalyzer create-analyzer \ --analyzer-name acesso-nao-utilizado \ --type ACCOUNT_UNUSED_ACCESS \ --configuration '{"unusedAccess": {"unusedAccessAge": 90}}' 

Esse tipo de analisador é cobrado por role/usuário analisado por mês. Confira o preço antes de ligar numa organização grande.

Resumo

  • Comece pelo último acesso: em 5 minutos você sabe o tamanho do problema.
  • Gere a policy pelo CloudTrail, substitua os placeholders e valide.
  • Prove com check-no-new-access que você só está tirando permissão.
  • Troque em etapas e com plano de volta.

Menor privilégio não é um projeto que termina. Mas sair de AdministratorAccess para uma policy com 20 ações já reduz o estrago de qualquer credencial vazada em ordens de grandeza.