IAMComunidade
Nível de dificuldade: Avançado (4 de 5)
Como desenhar roles IAM na AWS que resistem à escalação de privilégios
Quem desenha trust policies, pipelines de CI/CD com OIDC e roles de execução de Lambda no dia a dia conhece a cena: a política parece enxuta, passou no code review, e mesmo assim existe um caminho até AdministratorAccess escondido nela. É esse o problema que Tom Jose, engenheiro de DevOps da KotaiCode, detalha num artigo publicado em 19 de novembro de 2026 no Medium, usando como fio condutor uma role de deploy de funções Lambda.
O ponto central: nenhuma das permissões do exemplo concede admin diretamente. iam:PassRole com Resource: "*", permissão para atualizar código de uma Lambda, ou para publicar uma nova versão de política, nenhuma dessas aparece como risco óbvio numa revisão. Mas cada uma pode ser o primeiro passo de uma cadeia que termina em controle total da conta.
Por que o least privilege sozinho não resolve
Least privilege pergunta se uma role tem mais permissão do que precisa. Escalação pergunta outra coisa: essa role consegue usar o que já tem para conseguir mais? Uma role pode passar no primeiro teste e falhar no segundo.
O artigo separa três categorias de permissão perigosa. A primeira modifica o IAM diretamente: anexar política, escrever política inline, editar trust policy. A segunda altera o poder de uma identidade existente de forma indireta, como publicar uma nova versão padrão de uma política já anexada a uma role. A terceira entrega uma role para um serviço da AWS executar código em nome dela, e essa é a mais difícil de enxergar, porque a permissão concedida nunca menciona a role poderosa que está por trás.
O trust policy que engana
Um erro comum mora no principal de uma trust policy que parece específico:
{
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::210987654321:root" },
"Action": "sts:AssumeRole"
}Isso não significa "só o usuário root". Significa "qualquer principal na conta 210987654321 cuja própria política permita sts:AssumeRole nesta role". A decisão de confiança fica delegada a toda política de identidade da conta, e qualquer role com sts:AssumeRole em *, comum em pipelines de CI antigos, consegue assumir essa role.
O ajuste é nomear o ARN exato do principal e travar com aws:PrincipalOrgID (para contas dentro da organização) ou sts:ExternalId (contra o problema do confused deputy, com terceiros). Para OIDC de CI/CD, as condições de sub e aud precisam ser exatas, nunca wildcard cobrindo repositórios ou branches inteiros. Resource control policies no nível da Organization também ajudam aqui, porque se aplicam ao STS e evitam que uma trust policy descuidada de um time abra a role para fora da organização.
O cenário: deploy de Lambda com PassRole aberto
O exemplo do artigo é uma role de pipeline que faz deploy de funções do serviço orders:
{
"Action": ["lambda:CreateFunction", "lambda:UpdateFunctionCode", "lambda:UpdateFunctionConfiguration", "lambda:PublishVersion", "lambda:UpdateAlias"],
"Resource": "*"
},
{
"Action": "iam:PassRole",
"Resource": "*"
}Parece uma role de deploy sem nenhuma escrita em IAM. Mas iam:PassRole em * permite que o pipeline crie ou reconfigure uma função para rodar como qualquer role da conta que confie em lambda.amazonaws.com. Se existir uma role de "automação" antiga, esquecida, com privilégios amplos e trust policy aberta para o Lambda, o pipeline consegue fazer deploy de código que roda com essa role. E lambda:UpdateFunctionCode em * dispensa até o PassRole: dá para alterar o código de funções que já rodam com roles poderosas.
O teto real de permissão desse pipeline não é a política dele. É a role mais privilegiada que confia no Lambda na conta inteira. Para medir essa exposição, o artigo sugere listar todas as roles que o Lambda pode assumir:
aws iam list-roles --output json \
| jq -r '.Roles[] | select([.AssumeRolePolicyDocument.Statement[]?.Principal.Service?] | tostring | contains("lambda.amazonaws.com")) | .Arn'Cada role dessa lista é alcançável por qualquer principal com iam:PassRole irrestrito e lambda:CreateFunction. Um achado comum: uma role legada com AdministratorAccess, criada para uma migração pontual, nunca removida, nunca usada, mas ainda confiando no Lambda.
Fechando o vetor: role de execução dedicada e PassedToService
A correção tem quatro partes: limitar o que o pipeline toca, limitar quais roles ele pode passar, dar à função uma role mínima, e restringir qualquer role que o pipeline venha a criar.
Primeiro, uma role de execução dedicada por serviço, sob um path que a identifica (lambda-exec/orders-*), com só as permissões que a função orders precisa de DynamoDB e logs. Depois, a role de deploy, restrita aos seus próprios recursos:
{
"Sid": "PassOnlyOrdersExecutionRoles",
"Resource": "arn:aws:iam::210987654321:role/lambda-exec/orders-*",
"Condition": {
"StringEquals": { "iam:PassedToService": "lambda.amazonaws.com" }
}
}O iam:PassedToService importa mesmo com o Resource já restrito: sem ele, a mesma role poderia ser passada para qualquer serviço que a aceite, e alguns oferecem caminhos bem mais diretos para executar código arbitrário do que o Lambda. Um detalhe que complica a auditoria: iam:PassRole é uma checagem de permissão, não uma chamada de API, então não aparece como evento próprio no CloudTrail. O que aparece é a chamada de serviço que o usou, como CreateFunction com o parâmetro role preenchido.
Permission boundaries como teto para o que o pipeline cria
Se o pipeline também cria roles de execução, via Terraform ou CDK, restringir PassRole não basta: ele poderia criar uma role nova e ampla e passar essa. Uma permission boundary resolve isso impondo um teto: o pipeline só cria ou edita roles sob o path de execução, e só se a role carregar a boundary certa.
A política efetiva de uma role é a interseção entre a política própria e a boundary, então mesmo que o pipeline escreva "Action": "*" numa role de execução, ela não ultrapassa o que a boundary permite. Mas boundaries têm limite: não travam acesso que uma política baseada em recurso concede diretamente, não valem para roles criadas por quem não está sujeito à condição, e só são tão fortes quanto a própria proteção. Um pipeline capaz de editar a política de boundary, ou de remover a boundary de uma role, tem um caminho de escalação de um passo só.
SCPs e deny explícito: a camada que o admin da conta não derruba
A AWS avalia toda requisição em camadas: um deny explícito vence em qualquer lugar; do contrário, é preciso um allow da política de identidade e também caber dentro de todo teto aplicável (SCP, boundary, session policy). É por isso que SCPs são o lugar certo para regras que precisam valer mesmo se um administrador de conta errar o IAM: proteger as políticas de boundary contra edição, impedir remoção de boundary de roles de execução, proteger roles de plataforma contra UpdateAssumeRolePolicy e DeleteRole, e bloquear criação de usuários IAM e access keys fora de um caminho de break-glass.
Duas limitações de SCP importam no desenho: elas não se aplicam à management account da organização, então nada sensível deveria rodar ali, e não restringem service-linked roles. Separar contas de staging e produção, com roles de deploy distintas e trust OIDC amarrado ao ambiente exato do GitHub, fecha outro buraco: um pipeline comprometido em staging fica sem rota nenhuma até produção.
Testar guardrails como se fossem código
Guardrail que não é testado degrada. O IAM Policy Simulator responde se um principal pode executar uma ação específica, considerando políticas de identidade, boundaries e SCPs juntas, e pode rodar no CI contra a role de deploy:
aws iam simulate-principal-policy \
--policy-source-arn arn:aws:iam::210987654321:role/ci/orders-deploy-prod \
--action-names iam:PassRole \
--resource-arns arn:aws:iam::210987654321:role/platform/automation-adminO resultado esperado é implicitDeny ou explicitDeny; se vier allowed, o build deveria falhar. O IAM Access Analyzer complementa com check-access-not-granted, que barra uma política antes do deploy se ela conceder qualquer ação de uma lista sensível (iam:AttachRolePolicy, iam:PutRolePolicy, iam:CreatePolicyVersion, iam:UpdateAssumeRolePolicy, iam:CreateAccessKey). Para enxergar rotas de múltiplos passos numa conta com centenas de roles, o artigo cita o PMapper, ferramenta open source que constrói o grafo de quem pode alcançar quem.
As permissões reais de uma role não são as ações listadas na política dela. São tudo que é alcançável a partir dessas ações: cada role que ela pode passar, cada função cujo código ela pode alterar, cada política que ela pode reescrever.
A role's real permissions aren't the actions listed in its policy. They're everything reachable from those actions: every role it can pass, every function whose code it can change, every policy it can rewrite.Tom Jose, DevOps Engineer na KotaiCode
O que revisar primeiro
Para quem administra trust policies e pipelines de deploy, o checklist do artigo serve de ponto de partida direto na próxima auditoria:
- Nenhuma trust policy usa principal
rootda conta onde um ARN de role específico resolveria - Trust cross-account usa
aws:PrincipalOrgID; terceiros usamsts:ExternalId; OIDC usasubeaudexatos iam:PassRolerestrito a paths específicos e travado comiam:PassedToService- Permissões de atualização de código (
lambda:UpdateFunctionCode,ssm:SendCommand) escopadas a recursos cujas roles já foram revisadas - Roles criadas por automação carregam permission boundary obrigatória
- SCPs protegem boundaries, seus anexos e roles de plataforma
- Sem usuários IAM nem access keys fora de um caminho de break-glass
- Staging e produção fazem deploy de contas separadas, com roles separadas
- Policy Simulator e Access Analyzer rodam no CI para roles sensíveis
- CloudTrail alerta sobre mudanças de forma no IAM e parâmetros de role fora do esperado
Nenhuma dessas camadas sozinha fecha tudo. O valor está em empilhar: uma role sem PassRole irrestrito, com boundary, protegida por SCP e testada no CI tem um teto que resiste mesmo quando uma das camadas falha.
Fonte: Medium — tag aws
Serviços neste textoIAM
Leve para a sua IA
Decida com o seu assistente, com o contexto deste texto já montado.
1. O que você quer saber
Ver o prompt
Li no AWS Hub: "Como desenhar roles IAM na AWS que resistem à escalação de privilégios" (https://awshub.com.br/comunidade/como-desenhar-roles-iam-na-aws-que-resistem-a-escalacao-de-privilegios). Resumo: Um guia publicado no Medium por um engenheiro da KotaiCode mapeia os vetores de escalação que passam longe do AdministratorAccess, como iam:PassRole aberto e trust policies com principal root, e mostra onde boundaries e SCPs entram para fechar o cerco. Serviços: IAM Minha stack: [descreva em uma linha: serviços, linguagem, volume, região] Isso muda alguma coisa na minha arquitetura? O que eu faria diferente a partir de amanhã?