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

Resposta a Incidente na AWS #1: sua access key vazou, os primeiros 60 minutos

Essa série conta um incidente fictício do começo ao fim, mas montado com o que acontece de verdade em ambiente de produção. Todos os nomes, contas e chaves são placeholders. Troque pelos seus. O cenário Sexta

Essa série conta um incidente fictício do começo ao fim, mas montado com o que acontece de verdade em ambiente de produção. Todos os nomes, contas e chaves são placeholders. Troque pelos seus.

O cenário

Sexta, 22h47. Chega um e-mail da AWS com o assunto de credencial exposta e, no AWS Health, aparece o evento AWS_RISK_CREDENTIALS_EXPOSED. A chave AKIA<XXXXXXXXXXXX> do usuário svc-<app>-deploy, na conta <ACCOUNT_ID>, foi encontrada num repositório público.

A própria AWS já anexou a policy gerenciada AWSCompromisedKeyQuarantineV3 no usuário. Ela nega um monte de ações perigosas, mas não revoga a chave. E, quando você olha o GuardDuty, já tem finding de CryptoCurrency:EC2/BitcoinTool.B!DNS em us-east-1, região que a empresa nem usa.

O relógio começou a correr. O objetivo da primeira hora é: conter, preservar evidência e entender o alcance. Erradicar e recuperar vem depois.

Antes de tudo: variáveis

Todos os comandos abaixo usam estas variáveis. Rode com um perfil de administrador que não seja o comprometido.

export AWS_PROFILE="<PERFIL_ADMIN_IR>"
export ACCOUNT_ID="<ACCOUNT_ID>"
export USER_NAME="svc-<app>-deploy"
export KEY_ID="AKIA<XXXXXXXXXXXX>"
export IR_BUCKET="<BUCKET_EVIDENCIAS_IR>"

Minuto 0 a 10: conter a chave

1. Desativar, não deletar

Desativar mantém o registro da chave (útil pra investigação e pra auditoria). Deletar você faz no final.

aws iam update-access-key \
  --user-name "$USER_NAME" \
  --access-key-id "$KEY_ID" \
  --status Inactive

aws iam list-access-keys --user-name "$USER_NAME" \
  --query 'AccessKeyMetadata[].[AccessKeyId,Status,CreateDate]' --output table

2. Cortar as sessões temporárias que o atacante já gerou

Esse é o ponto que quase todo mundo esquece. Se o atacante rodou sts get-session-token ou sts get-federation-token com a chave, ele tem credenciais temporárias que continuam válidas mesmo com a chave desativada.

A saída é uma policy inline que nega tudo para tokens emitidos antes de agora:

NOW="$(date -u +%Y-%m-%dT%H:%M:%SZ)"

cat > /tmp/revoke-sessions.json <<EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "RevogarSessoesAntigas",
      "Effect": "Deny",
      "Action": "*",
      "Resource": "*",
      "Condition": {
        "DateLessThan": { "aws:TokenIssueTime": "$NOW" }
      }
    }
  ]
}
EOF

aws iam put-user-policy \
  --user-name "$USER_NAME" \
  --policy-name IR-RevogarSessoes \
  --policy-document file:///tmp/revoke-sessions.json

3. Roles que a chave conseguia assumir

Se o usuário tinha permissão de sts:AssumeRole, o atacante pode ter assumido roles e estar usando essas sessões. Descubra quais roles foram assumidas (vamos ver no CloudTrail logo abaixo) e aplique a mesma ideia na role. É exatamente o que o botão "Revoke active sessions" do console faz:

ROLE_NAME="<ROLE_ASSUMIDA>"
aws iam put-role-policy \
  --role-name "$ROLE_NAME" \
  --policy-name AWSRevokeOlderSessions \
  --policy-document file:///tmp/revoke-sessions.json

Cuidado: isso derruba também as sessões legítimas da role. Aplicações que usam a role vão renovar as credenciais sozinhas, mas avise o time.

4. Login de console

Se o usuário tinha senha, remova:

aws iam get-login-profile --user-name "$USER_NAME" 2>/dev/null \
  && aws iam delete-login-profile --user-name "$USER_NAME"

Minuto 10 a 20: preservar evidência

Antes de começar a apagar instância de minerador, garanta que os logs estão a salvo.

# A trilha está ligada e com validação de integridade?
aws cloudtrail describe-trails \
  --query 'trailList[].[Name,S3BucketName,IsMultiRegionTrail,LogFileValidationEnabled]' \
  --output table

aws cloudtrail get-trail-status --name "<NOME_DA_TRILHA>" \
  --query '[IsLogging,LatestDeliveryTime]'

Se a trilha estiver desligada, foi o atacante ou nunca existiu. Nos dois casos, o Event History do CloudTrail ainda guarda 90 dias de eventos de gerenciamento por região. Exporte agora:

for REGION in $(aws ec2 describe-regions --query 'Regions[].RegionName' --output text); do
  aws cloudtrail lookup-events \
    --region "$REGION" \
    --lookup-attributes AttributeKey=AccessKeyId,AttributeValue="$KEY_ID" \
    --max-results 50 \
    --output json > "evidencia-lookup-${REGION}.json"
  echo "$REGION: $(jq '.Events | length' "evidencia-lookup-${REGION}.json") eventos"
done

aws s3 cp . "s3://${IR_BUCKET}/incidente-<ID>/cloudtrail-lookup/" \
  --recursive --exclude '*' --include 'evidencia-lookup-*.json'

O lookup-events pagina sozinho quando você não passa --max-results. Aqui limitei a 50 só pra ter uma visão rápida por região. Para o export completo, tire o parâmetro.

Minuto 20 a 45: linha do tempo no Athena

O lookup-events é ótimo pra começar, mas pra responder "o que ele fez, onde e em que ordem" o Athena em cima da trilha é muito mais rápido. (No post #5 da série eu deixo o DDL da tabela com partition projection.)

Tudo que a chave fez

SELECT
  eventtime,
  awsregion,
  eventsource,
  eventname,
  sourceipaddress,
  useragent,
  errorcode
FROM cloudtrail_logs
WHERE useridentity.accesskeyid = 'AKIA<XXXXXXXXXXXX>'
  AND "timestamp" >= '2026/11/01'
ORDER BY eventtime;

Quais IPs e user agents usaram a chave

SELECT
  sourceipaddress,
  useragent,
  min(eventtime) AS primeiro_uso,
  max(eventtime) AS ultimo_uso,
  count(*) AS chamadas
FROM cloudtrail_logs
WHERE useridentity.accesskeyid = 'AKIA<XXXXXXXXXXXX>'
  AND "timestamp" >= '2026/11/01'
GROUP BY sourceipaddress, useragent
ORDER BY primeiro_uso;

Aqui você normalmente separa o IP do seu pipeline de CI do IP do atacante.

Sessões temporárias que nasceram dessa chave

O pulo do gato: credenciais temporárias têm outra access key (ASIA...). Para seguir o atacante depois que ele trocou de credencial, procure os AssumeRole e GetSessionToken feitos pela chave e depois tudo que as ASIA resultantes fizeram.

SELECT
  eventtime,
  eventname,
  json_extract_scalar(requestparameters, '$.roleArn') AS role_assumida,
  json_extract_scalar(responseelements, '$.credentials.accessKeyId') AS chave_temporaria
FROM cloudtrail_logs
WHERE useridentity.accesskeyid = 'AKIA<XXXXXXXXXXXX>'
  AND eventname IN ('AssumeRole', 'GetSessionToken', 'GetFederationToken')
  AND "timestamp" >= '2026/11/01'
ORDER BY eventtime;

Pegue cada chave_temporaria e rode a primeira query de novo trocando o filtro.

O que foi criado

SELECT eventtime, awsregion, eventname, requestparameters
FROM cloudtrail_logs
WHERE useridentity.accesskeyid IN ('AKIA<XXXXXXXXXXXX>', '<ASIA_DA_SESSAO>')
  AND readonly = 'false'
  AND errorcode IS NULL
  AND "timestamp" >= '2026/11/01'
ORDER BY eventtime;

Essa é a lista de trabalho pra erradicação: instâncias, usuários, keys, roles, Lambdas, regras do EventBridge, security groups.

Minuto 45 a 60: estancar o custo

Minerador custa caro e rápido. Liste instâncias em todas as regiões e compare com o que é legítimo:

for REGION in $(aws ec2 describe-regions --query 'Regions[].RegionName' --output text); do
  aws ec2 describe-instances --region "$REGION" \
    --filters Name=instance-state-name,Values=pending,running \
    --query 'Reservations[].Instances[].[InstanceId,InstanceType,LaunchTime,KeyName]' \
    --output text | sed "s/^/${REGION}\t/"
done

Para as instâncias do atacante, pare (não termine ainda) e proteja contra término até a análise terminar:

REGION="us-east-1"
INSTANCE_ID="i-<ID_DO_ATACANTE>"

aws ec2 modify-instance-attribute --region "$REGION" \
  --instance-id "$INSTANCE_ID" --disable-api-termination

aws ec2 stop-instances --region "$REGION" --instance-ids "$INSTANCE_ID"

Parar mantém o volume pra forense (post #4) e já zera o custo de computação.

Checklist da primeira hora

  • [ ] Chave desativada (não deletada)
  • [ ] Policy de revogação de sessões aplicada no usuário
  • [ ] Sessões revogadas nas roles que a chave assumiu
  • [ ] Login profile removido
  • [ ] Trilha do CloudTrail ativa e eventos exportados para bucket de evidências
  • [ ] Linha do tempo inicial no Athena (IPs, sessões, recursos criados)
  • [ ] Instâncias do atacante paradas e com proteção de término
  • [ ] Caso aberto no AWS Support informando o incidente
  • [ ] Time e gestão avisados

Depois da primeira hora

  • Procurar persistência (usuários, roles com trust externo, Lambdas agendadas). É o assunto do post #3.
  • Fazer a forense das instâncias criadas e da origem do vazamento (post #4).
  • Trocar a chave na aplicação por uma role. Pipeline com access key fixa é a causa raiz número um desse tipo de incidente. GitHub Actions, GitLab CI e Bitbucket suportam OIDC com sts:AssumeRoleWithWebIdentity.
  • Remover o segredo do histórico do Git (rotacionar não basta pra apagar, mas é o que importa: a chave antiga tem que morrer).

No próximo post: o atacante não entrou só pela chave. Tinha um banco PostgreSQL com a porta aberta e um minerador rodando há dias.

📰 Read the original article on Dev.to Security

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