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

Resposta a Incidente na AWS #2: minerador no banco de produção, anatomia de uma EC2 comprometida

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-

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.

📰 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.