Dev.to Security 🔐 Cybersecurity 👁 0 📖 5 min read

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:

  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.

📰 Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.