Continuando a série. Nomes, IDs e IPs são todos placeholders.

O cenário

Enquanto o time ainda tratava a access key vazada do post #1, alguém percebeu que a EC2 do PostgreSQL de produção, i-<ID_DB> em sa-east-1, estava com CPU travada em 100% há quatro dias. Ninguém tinha alarme de CPU nela.

O que estava lá:

  • Security group com 5432/tcp liberado para 0.0.0.0/0 ("era só pra testar").
  • Usuário postgres com senha fraca.
  • Um processo chamado kdevtmpfsi consumindo todos os cores.
  • Conexões de saída para portas como 3333, 5555 e 7777, típicas de pool de mineração.

Esse é um dos vetores mais comuns de minerador em banco: o atacante entra com usuário superuser e usa COPY ... FROM PROGRAM para rodar comando no sistema operacional. A partir daí, baixa o binário, cria persistência e começa a minerar.

A tentação é dar kill -9, apagar o binário e seguir a vida. Não faça isso. Primeiro isola, depois coleta, depois decide.

Variáveis

export AWS_PROFILE="<PERFIL_ADMIN_IR>" export AWS_REGION="sa-east-1" export INSTANCE_ID="i-<ID_DB>" export VPC_ID="vpc-<ID>" export INCIDENTE="<ID_INCIDENTE>" 

Passo 1: proteger a instância contra você mesmo

aws ec2 modify-instance-attribute --instance-id "$INSTANCE_ID" --disable-api-termination aws ec2 create-tags --resources "$INSTANCE_ID" --tags \ Key=ir-status,Value=quarentena \ Key=ir-incidente,Value="$INCIDENTE" 

A tag ajuda o resto do time a não "consertar" a máquina no meio da investigação.

Passo 2: isolar a rede do jeito certo

Aqui está o detalhe que pouca gente conhece. Security group é stateful: quando você troca as regras, conexões que já estão sendo rastreadas (tracked) continuam funcionando. Ou seja, trocar o SG por um vazio não necessariamente derruba a conexão do atacante com o pool ou com o C2.

A AWS documenta isso: conexões são rastreadas quando existe regra que não é "tudo liberado". O truque usado em resposta a incidente é em dois tempos:

  1. Aplicar um SG que libera todo o tráfego de entrada e saída para 0.0.0.0/0. Com isso, as conexões passam a ser untracked.
  2. Na sequência, trocar por um SG sem nenhuma regra. Como as conexões estavam untracked, elas caem na hora.
SG_UNTRACK=$(aws ec2 create-security-group --vpc-id "$VPC_ID" \ --group-name "ir-${INCIDENTE}-untrack" \ --description "IR passo 1 - torna conexoes untracked" \ --query GroupId --output text) aws ec2 authorize-security-group-ingress --group-id "$SG_UNTRACK" \ --ip-permissions 'IpProtocol=-1,IpRanges=[{CidrIp=0.0.0.0/0}]' # a regra de saida "tudo liberado" ja vem por padrao SG_ISOLA=$(aws ec2 create-security-group --vpc-id "$VPC_ID" \ --group-name "ir-${INCIDENTE}-isolamento" \ --description "IR passo 2 - sem entrada e sem saida" \ --query GroupId --output text) aws ec2 revoke-security-group-egress --group-id "$SG_ISOLA" \ --ip-permissions 'IpProtocol=-1,IpRanges=[{CidrIp=0.0.0.0/0}]' # Aplica os dois em sequencia aws ec2 modify-instance-attribute --instance-id "$INSTANCE_ID" --groups "$SG_UNTRACK" sleep 5 aws ec2 modify-instance-attribute --instance-id "$INSTANCE_ID" --groups "$SG_ISOLA" 

Esse modify-instance-attribute --groups só funciona para instância com uma ENI. Se tiver mais de uma, faça o mesmo em cada ENI com aws ec2 modify-network-interface-attribute.

Se a instância tem role, tire também, porque o atacante pode estar usando as credenciais dela:

ASSOC_ID=$(aws ec2 describe-iam-instance-profile-associations \ --filters Name=instance-id,Values="$INSTANCE_ID" \ --query 'IamInstanceProfileAssociations[0].AssociationId' --output text) [ "$ASSOC_ID" != "None" ] && aws ec2 disassociate-iam-instance-profile --association-id "$ASSOC_ID" 

E revogue as sessões já emitidas para a role (mesma policy com aws:TokenIssueTime do post #1).

Passo 3: snapshot antes de qualquer coisa

for VOL in $(aws ec2 describe-instances --instance-ids "$INSTANCE_ID" \ --query 'Reservations[].Instances[].BlockDeviceMappings[].Ebs.VolumeId' --output text); do aws ec2 create-snapshot --volume-id "$VOL" \ --description "IR ${INCIDENTE} - ${INSTANCE_ID} - ${VOL}" \ --tag-specifications "ResourceType=snapshot,Tags=[{Key=ir-incidente,Value=${INCIDENTE}},{Key=ir-origem,Value=${VOL}}]" \ --query SnapshotId --output text done 

Com o volume a salvo, você pode olhar a máquina viva sem medo. O tratamento forense completo do snapshot fica pro post #4.

Passo 4: coleta na máquina viva (sem SSH)

Com o SG fechado, você não entra por SSH. E nem deveria: SSH com a chave do time numa máquina comprometida é péssima ideia. Use o SSM Session Manager, que funciona se a instância tiver o agente e conseguir falar com os endpoints do SSM.

Se a instância está totalmente isolada e não tem VPC endpoint do SSM, o SSM não vai responder. Nesse caso, a coleta viva fica pra depois e você trabalha só com o snapshot. É uma troca consciente: isolamento total vale mais do que a memória RAM na maioria dos casos.

Rodando a coleta via Run Command e guardando a saída no S3:

cat > /tmp/coleta.json <<'EOF' { "commands": [ "date -u", "uptime", "ps auxwwf", "ss -tupan", "ls -la /tmp /var/tmp /dev/shm", "crontab -l -u postgres", "crontab -l -u root", "ls -la /etc/cron.d /etc/cron.hourly /etc/cron.daily /var/spool/cron", "systemctl list-units --type=service --state=running --no-pager", "cat /root/.ssh/authorized_keys /var/lib/postgresql/.ssh/authorized_keys", "cat /etc/ld.so.preload", "last -Faiw | head -50", "find / -xdev -newermt '-7 days' -type f -perm -u+x 2>/dev/null" ] } EOF aws ssm send-command \ --instance-ids "$INSTANCE_ID" \ --document-name AWS-RunShellScript \ --comment "IR ${INCIDENTE} coleta viva" \ --output-s3-bucket-name "<BUCKET_EVIDENCIAS_IR>" \ --output-s3-key-prefix "incidente-${INCIDENTE}/coleta-viva" \ --parameters file:///tmp/coleta.json 

O que procurar

Processos e rede

  • Processo com nome de kernel thread (kdevtmpfsi, kworkerds, [kthreadd] sem colchete de verdade), rodando como postgres.
  • Conexões ESTAB para portas de pool e para IPs que não são seus.
  • Binário apagado do disco mas ainda rodando: ls -la /proc/<PID>/exe aponta para (deleted). Dá pra recuperar com cp /proc/<PID>/exe /tmp/evidencia.bin.

Persistência no Linux

  • crontab do usuário postgres com curl ou wget piped para sh.
  • Arquivo .service novo em /etc/systemd/system/.
  • Chave SSH desconhecida em authorized_keys.
  • Alterações em /etc/ld.so.preload (rootkit userland que esconde processo do ps).
  • Binário com nome aleatório em /tmp, /var/tmp ou /dev/shm.

No PostgreSQL

Se o banco ainda responde localmente, olhe os roles e o que foi executado:

-- Quem é superuser? SELECT rolname, rolsuper, rolcanlogin, rolvaliduntil FROM pg_roles WHERE rolsuper OR rolcreaterole; -- Conexões ativas e o que estão rodando SELECT pid, usename, client_addr, backend_start, state, left(query, 120) AS query FROM pg_stat_activity WHERE backend_type = 'client backend'; 

E nos logs do PostgreSQL, procure COPY com PROGRAM:

grep -E -i "copy .* from program" /var/log/postgresql/*.log 

Por que não "limpar e seguir"

Porque você não sabe tudo o que o atacante fez. Minerador é o sintoma barulhento. Com acesso de superuser ao banco, ele pode ter:

  • Exfiltrado dados (aí o problema vira LGPD, não só custo).
  • Criado role de banco extra para voltar depois.
  • Usado a role da instância para ir para outros serviços da conta.

O caminho certo é: reconstruir a instância a partir de uma base limpa, restaurar os dados a partir de um backup anterior ao comprometimento (ou validado), trocar todas as senhas e não expor mais o banco.

Checklist

  • [ ] Proteção de término e tags de quarentena
  • [ ] Isolamento em dois tempos (untracked e depois sem regras)
  • [ ] Instance profile removido e sessões da role revogadas
  • [ ] Snapshot de todos os volumes com tags de incidente
  • [ ] Coleta viva via SSM salva no S3 (se possível)
  • [ ] IOCs anotados: hashes, IPs, domínios, nomes de processo, caminhos
  • [ ] Decisão de reconstrução documentada

Prevenção

  • Banco nunca em subnet pública e nunca com 0.0.0.0/0. Se precisar acesso externo, VPN ou SSM port forwarding.
  • Alarme de CPU e de NetworkOut em tudo que é produção.
  • GuardDuty ligado, com Runtime Monitoring onde fizer sentido. Ele pega minerador por DNS e por comportamento.
  • Melhor ainda: RDS no lugar de PostgreSQL em EC2. No RDS ninguém consegue COPY FROM PROGRAM porque o usuário master não é superuser de verdade.

No próximo post: o incidente "acabou", mas o atacante deixou portas abertas no IAM. Vamos caçar persistência.