Menor privilégio de verdade: gerando policies a partir do uso real com IAM Access Analyzer
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
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:
- Último acesso por serviço: o que a role usou e quando.
- Geração de policy: monta uma policy com base no que a role realmente fez, lendo o CloudTrail.
- 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:Decryptna 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:
- Anexe a nova policy junto com a antiga. Nada muda, porque a antiga ainda libera tudo.
- Teste em homologação removendo a antiga lá primeiro.
- Em produção, remova a antiga numa janela, com o time da aplicação acompanhando.
- 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-accessque 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.
Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.