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

Resposta a Incidente na AWS #4: forense em EBS sem estragar a evidência

Último post da série. Placeholders em tudo. O cenário A EC2 do PostgreSQL comprometida (post #2) está isolada e com snapshot. Agora o jurídico quer saber se houve exfiltração de dados de clientes, e a auditor

Último post da série. Placeholders em tudo.

O cenário

A EC2 do PostgreSQL comprometida (post #2) está isolada e com snapshot. Agora o jurídico quer saber se houve exfiltração de dados de clientes, e a auditoria pede cadeia de custódia: quem tocou na evidência, quando, e como provar que ela não foi alterada.

Analisar o disco dentro da conta comprometida é pedir pra ter problema. O atacante pode ainda ter algum acesso, e qualquer pessoa com admin na conta pode apagar o snapshot. A prática recomendada é ter uma conta forense separada, dentro da Organization, com acesso restrito ao time de segurança.

  • Conta comprometida: <ACCOUNT_ID_VITIMA>
  • Conta forense: <ACCOUNT_ID_FORENSE>
  • Região: sa-east-1

Passo 1: snapshot com tags de custódia

Se você já fez no post #2, só complete as tags. Se não, faça agora:

export AWS_PROFILE="<PERFIL_CONTA_VITIMA>"
export AWS_REGION="sa-east-1"
VOL="vol-<ID>"
INCIDENTE="<ID_INCIDENTE>"

SNAP=$(aws ec2 create-snapshot --volume-id "$VOL" \
  --description "IR ${INCIDENTE} evidencia ${VOL}" \
  --tag-specifications "ResourceType=snapshot,Tags=[{Key=ir-incidente,Value=${INCIDENTE}},{Key=ir-coletado-por,Value=<SEU_USUARIO>},{Key=ir-coletado-em,Value=$(date -u +%Y-%m-%dT%H:%M:%SZ)},{Key=ir-origem,Value=${VOL}}]" \
  --query SnapshotId --output text)

aws ec2 wait snapshot-completed --snapshot-ids "$SNAP"
echo "$SNAP"

Passo 2: o problema da chave KMS

Aqui muita gente trava. Se o volume estava criptografado com a chave padrão aws/ebs, o snapshot não pode ser compartilhado com outra conta. Chaves gerenciadas pela AWS não aceitam policy de cross-account.

A saída é copiar o snapshot recriptografando com uma chave KMS gerenciada pelo cliente, que tenha policy liberando a conta forense.

Policy mínima da chave (na conta vítima). Note que ela libera o root da própria conta, para você não se trancar fora, e a conta forense só para usar a chave:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AdminDaPropriaConta",
      "Effect": "Allow",
      "Principal": { "AWS": "arn:aws:iam::<ACCOUNT_ID_VITIMA>:root" },
      "Action": "kms:*",
      "Resource": "*"
    },
    {
      "Sid": "ContaForenseUsaAChave",
      "Effect": "Allow",
      "Principal": { "AWS": "arn:aws:iam::<ACCOUNT_ID_FORENSE>:root" },
      "Action": [
        "kms:Decrypt",
        "kms:DescribeKey",
        "kms:CreateGrant",
        "kms:ReEncrypt*",
        "kms:GenerateDataKey*"
      ],
      "Resource": "*"
    }
  ]
}
KEY_ID=$(aws kms create-key \
  --description "IR ${INCIDENTE} compartilhamento de evidencia" \
  --policy file://kms-policy-ir.json \
  --query KeyMetadata.KeyId --output text)

SNAP_CMK=$(aws ec2 copy-snapshot \
  --source-region "$AWS_REGION" \
  --source-snapshot-id "$SNAP" \
  --encrypted --kms-key-id "$KEY_ID" \
  --description "IR ${INCIDENTE} copia para conta forense" \
  --query SnapshotId --output text)

aws ec2 wait snapshot-completed --snapshot-ids "$SNAP_CMK"

aws ec2 modify-snapshot-attribute --snapshot-id "$SNAP_CMK" \
  --attribute createVolumePermission --operation-type add \
  --user-ids "<ACCOUNT_ID_FORENSE>"

Passo 3: na conta forense, copiar de novo

Por que copiar de novo? Porque um snapshot compartilhado continua pertencendo à conta vítima. Se alguém lá apagar, você perde. A cópia na conta forense é sua.

export AWS_PROFILE="<PERFIL_CONTA_FORENSE>"

SNAP_FORENSE=$(aws ec2 copy-snapshot \
  --source-region sa-east-1 \
  --source-snapshot-id "$SNAP_CMK" \
  --encrypted --kms-key-id "<KEY_ID_DA_CONTA_FORENSE>" \
  --description "IR ${INCIDENTE} evidencia custodiada" \
  --tag-specifications "ResourceType=snapshot,Tags=[{Key=ir-incidente,Value=${INCIDENTE}},{Key=ir-snapshot-origem,Value=${SNAP}}]" \
  --query SnapshotId --output text)

aws ec2 wait snapshot-completed --snapshot-ids "$SNAP_FORENSE"

Bônus: trave o snapshot contra exclusão com o Snapshot Lock do EBS, em modo compliance, pelo tempo que a retenção exigir:

aws ec2 lock-snapshot --snapshot-id "$SNAP_FORENSE" \
  --lock-mode compliance --cool-off-period 24 --lock-duration 90

Em modo compliance, depois do período de cool-off ninguém apaga o snapshot antes do prazo. Nem você, nem o root. Use com consciência.

Passo 4: a estação forense

Uma EC2 na conta forense, numa subnet sem rota para a internet (acesso via SSM com VPC endpoints), com as ferramentas já instaladas na AMI. Crie o volume a partir do snapshot na mesma AZ da estação:

VOL_EVID=$(aws ec2 create-volume --snapshot-id "$SNAP_FORENSE" \
  --availability-zone sa-east-1a --volume-type gp3 \
  --tag-specifications "ResourceType=volume,Tags=[{Key=ir-incidente,Value=${INCIDENTE}}]" \
  --query VolumeId --output text)

aws ec2 wait volume-available --volume-ids "$VOL_EVID"

aws ec2 attach-volume --volume-id "$VOL_EVID" \
  --instance-id "i-<ESTACAO_FORENSE>" --device /dev/sdf

Passo 5: hash e montagem somente leitura

Dentro da estação. Em instâncias Nitro o disco aparece como /dev/nvme1n1 (confira com lsblk).

# Hash do dispositivo inteiro antes de montar. Guarde esse valor no relatorio.
sudo sha256sum /dev/nvme1n1 | tee hash-${INCIDENTE}-antes.txt

# Bloqueia escrita no nivel do kernel
sudo blockdev --setro /dev/nvme1n1
sudo blockdev --getro /dev/nvme1n1   # deve retornar 1

sudo mkdir -p /mnt/evidencia
lsblk -f /dev/nvme1n1

Agora a montagem, e aqui tem um detalhe importante: só -o ro não basta para ext4 e xfs. Se o sistema de arquivos foi desligado "sujo" (e na instância comprometida provavelmente foi), o kernel tenta reproduzir o journal na montagem, e isso escreve no disco.

# ext4
sudo mount -o ro,noload,noexec /dev/nvme1n1p1 /mnt/evidencia

# xfs (troque a linha acima por esta)
# sudo mount -o ro,norecovery,nouuid,noexec /dev/nvme1n1p1 /mnt/evidencia

O nouuid do xfs é necessário quando a estação forense usa a mesma AMI do servidor original (UUID duplicado). O noexec evita que alguém rode o binário do atacante sem querer.

Passo 6: o que analisar

Linha do tempo de arquivos alterados

INICIO="2026-11-10 00:00"
sudo find /mnt/evidencia -xdev -newermt "$INICIO" -type f \
  -printf '%TY-%Tm-%Td %TH:%TM\t%u\t%m\t%s\t%p\n' 2>/dev/null \
  | sort > timeline-${INCIDENTE}.tsv

Logs

sudo ls -la /mnt/evidencia/var/log/
sudo grep -h -E "Accepted|Failed password" /mnt/evidencia/var/log/auth.log* 2>/dev/null | tail -100
sudo grep -h -i -E "copy .* from program|could not|authentication failed" \
  /mnt/evidencia/var/log/postgresql/*.log 2>/dev/null | tail -100

Persistência (os mesmos lugares do post #2, agora olhando o disco):

sudo cat /mnt/evidencia/var/spool/cron/crontabs/* 2>/dev/null
sudo ls -la /mnt/evidencia/etc/systemd/system/
sudo cat /mnt/evidencia/etc/ld.so.preload 2>/dev/null
sudo find /mnt/evidencia -name authorized_keys -exec ls -la {} \; -exec cat {} \;

Hash dos binários suspeitos para comparar em base de inteligência de ameaças:

sudo find /mnt/evidencia/tmp /mnt/evidencia/var/tmp /mnt/evidencia/dev/shm -type f \
  -exec sha256sum {} \; 2>/dev/null | tee iocs-hash-${INCIDENTE}.txt

Exfiltração: disco sozinho raramente prova exfiltração. Para isso você cruza com VPC Flow Logs (volume de bytes de saída para IPs desconhecidos no período) e com os logs do banco. Se não tinha Flow Logs ligado, registre isso como lacuna no relatório.

Passo 7: fechar a custódia

Ao final, desmonte e confirme que o hash não mudou:

sudo umount /mnt/evidencia
sudo sha256sum /dev/nvme1n1 | tee hash-${INCIDENTE}-depois.txt
diff <(cut -d' ' -f1 hash-${INCIDENTE}-antes.txt) <(cut -d' ' -f1 hash-${INCIDENTE}-depois.txt) \
  && echo "Integridade OK: hash identico antes e depois"

Suba os artefatos (timeline, hashes, IOCs) para um bucket de evidências com Object Lock e registre no relatório:

Item Valor
Snapshot original <SNAP_ID_ORIGINAL>
Snapshot custodiado <SNAP_ID_FORENSE>
SHA-256 do dispositivo <HASH>
Coletado por / em <NOME> / <DATA_UTC>
Analisado por / em <NOME> / <DATA_UTC>

Fechando a série

Os quatro posts formam o ciclo: conter a credencial, isolar o recurso, caçar a persistência e provar o que aconteceu. Se tem uma coisa pra levar daqui, é preparar antes: conta forense criada, bucket de evidências com Object Lock, CloudTrail organizacional e VPC Flow Logs ligados. No dia do incidente não dá tempo de montar nada disso.

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