DEV Community: Railander Marques

Resposta a incidente: EC2 com minerador e credencial da role vazada, da contenção à reconstrução

Railander Marques — Thu, 12 Nov 2026 12:24:29 +0000

1. Objetivo

Roteiro de resposta a incidente para uma EC2 Linux comprometida, no cenário mais comum que aparece em conta AWS: minerador de criptomoeda (XMRig ou parecido) rodando na instância, muitas vezes com roubo das credenciais da instance role via metadata.

A ideia é conter rápido sem destruir evidência, entender como o atacante entrou e o que ele fez com as credenciais, e só depois reconstruir. A ordem dos passos importa. Desligar a instância no susto é o erro mais comum, e ele apaga a memória, que é onde está boa parte da história.

Resultado esperado ao final:

Instância isolada na rede, fora do Auto Scaling e com proteção contra término.
Credenciais da role invalidadas.
Memória e artefatos voláteis coletados com hash.
Snapshots dos volumes em conta de forense.
Linha do tempo do ataque e lista de ações feitas com as credenciais roubadas.
Ambiente reconstruído a partir de imagem limpa.

2. Sinais típicos

Sinal	Onde aparece
CPU em 100% constante sem mudança de tráfego	CloudWatch `CPUUtilization`
`CryptoCurrency:EC2/BitcoinTool.B!DNS`	GuardDuty
`UnauthorizedAccess:IAMUser/InstanceCredentialExfiltration.OutsideAWS`	GuardDuty (credencial da role usada fora da AWS)
Conexões de saída para portas 3333, 4444, 5555, 7777, 14444	VPC Flow Logs
Processos com nome genérico (`kworker`, `systemd-xxx`, `.x`) em `/tmp` ou `/dev/shm`	Dentro da instância
Instâncias novas em regiões que você não usa	Billing, CloudTrail
E-mail da AWS sobre uso abusivo	Caixa do root da conta

Se apareceu o finding de exfiltração de credencial, o incidente não é só da instância. É da conta. Trate o passo 4 como prioridade.

3. Antes de começar

[ ] Abra um registro do incidente (ticket, documento) e anote cada comando com horário UTC. Isso vira o relatório depois.
[ ] Separe uma conta ou VPC de forense, sem rota para a internet e sem peering com produção.
[ ] Bucket S3 de evidências com versionamento e Object Lock, se possível.
[ ] Não use a instância comprometida para nada além da coleta.

export AWS_REGION="us-east-1"
export IID="i-<INSTANCE_ID>"
export VPC_ID="vpc-<ID>"
export ROLE_NAME="<ROLE_DA_INSTANCIA>"
export BUCKET_EVID="<BUCKET_EVIDENCIAS>"
export CASO="IR-$(date -u +%Y%m%d)-01"

4. Passo 1: Travar a instância

# Ninguem termina por engano (inclusive voce)
aws ec2 modify-instance-attribute --instance-id "$IID" --disable-api-termination
aws ec2 modify-instance-attribute --instance-id "$IID" --instance-initiated-shutdown-behavior stop

# Marca para todo mundo saber
aws ec2 create-tags --resources "$IID" \
  --tags Key=Incidente,Value="$CASO" Key=NaoMexer,Value=forense

Se a instância está num Auto Scaling group, tire de lá antes de qualquer coisa. Senão, quando você isolar a rede, o health check falha e o ASG termina a instância sozinho:

ASG=$(aws autoscaling describe-auto-scaling-instances --instance-ids "$IID" \
  --query 'AutoScalingInstances[0].AutoScalingGroupName' --output text)

if [ "$ASG" != "None" ]; then
  aws autoscaling detach-instances --instance-ids "$IID" \
    --auto-scaling-group-name "$ASG" --no-should-decrement-desired-capacity
fi

Se estiver atrás de load balancer, desregistre dos target groups. O ASG coloca uma instância nova no lugar e o serviço continua.

5. Passo 2: Isolar a rede (do jeito certo)

Aqui tem uma pegadinha que pouca gente conhece: trocar o security group não derruba conexões já rastreadas. Se o atacante tem uma sessão reversa aberta, ela continua viva depois que você coloca um SG sem regras.

O truque documentado no guia de resposta a incidentes da AWS é passar por um SG intermediário que deixa as conexões não rastreadas, e só então aplicar o SG de isolamento:

# SG 1: tudo liberado (0.0.0.0/0 entrada e saida em todos os protocolos = conexao nao rastreada)
SG_UNTRACK=$(aws ec2 create-security-group --group-name "ir-untrack-${CASO}" \
  --description "IR passo intermediario" --vpc-id "$VPC_ID" --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}]'

# SG 2: isolamento, sem nenhuma regra
SG_ISOL=$(aws ec2 create-security-group --group-name "ir-isolamento-${CASO}" \
  --description "IR isolamento" --vpc-id "$VPC_ID" --query GroupId --output text)
aws ec2 revoke-security-group-egress --group-id "$SG_ISOL" \
  --ip-permissions 'IpProtocol=-1,IpRanges=[{CidrIp=0.0.0.0/0}]'

# Aplica o 1 e logo depois o 2
aws ec2 modify-instance-attribute --instance-id "$IID" --groups "$SG_UNTRACK"
sleep 5
aws ec2 modify-instance-attribute --instance-id "$IID" --groups "$SG_ISOL"

Se a instância tem mais de uma ENI, repita para cada uma (modify-network-interface-attribute).

Conexão parada não é convertida. O truque funciona para conexões com tráfego passando no momento da troca. Uma shell reversa ociosa pode continuar rastreada e voltar a funcionar depois. Se você já sabe o IP do atacante (Flow Logs, ss da coleta), complemente com uma regra de deny na NACL da subnet para esse IP. A NACL é stateless e corta na hora, mas vale para a subnet inteira, então use regra específica.

E a coleta, se a rede está fechada? O SSM Agent precisa sair para os endpoints do Systems Manager, e a coleta do passo 5 manda arquivos para o S3. No SG de isolamento, libere só a saída 443 para o SG dos endpoints de interface ssm, ssmmessages e ec2messages, e para o prefix list do S3 (com VPC endpoint gateway do S3 na tabela de rotas):
PL_S3=$(aws ec2 describe-managed-prefix-lists \
  --filters Name=prefix-list-name,Values=com.amazonaws.${AWS_REGION}.s3 \
  --query 'PrefixLists[0].PrefixListId' --output text)

aws ec2 authorize-security-group-egress --group-id "$SG_ISOL" \
  --ip-permissions "IpProtocol=tcp,FromPort=443,ToPort=443,UserIdGroupPairs=[{GroupId=<SG_VPC_ENDPOINTS>}]" \
  "IpProtocol=tcp,FromPort=443,ToPort=443,PrefixListIds=[{PrefixListId=${PL_S3}}]"
Sem endpoint, a alternativa é coletar pelo snapshot e abrir mão da memória.

Desassocie também o Elastic IP, se houver, e anote qual era.

6. Passo 3: Invalidar as credenciais da role

As credenciais que o atacante pegou pelo IMDS continuam válidas até expirar (até 6 horas, dependendo do caso), e funcionam de qualquer lugar do mundo. Remover a role da instância não invalida o que já foi emitido.

Aplique uma deny para tudo emitido antes de agora. É o mesmo que o botão Revoke active sessions do console faz:

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

cat > deny-old-sessions.json <<EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Deny",
      "Action": "*",
      "Resource": "*",
      "Condition": { "DateLessThan": { "aws:TokenIssueTime": "${AGORA}" } }
    }
  ]
}
EOF

aws iam put-role-policy --role-name "$ROLE_NAME" \
  --policy-name "AWSRevokeOlderSessions" \
  --policy-document file://deny-old-sessions.json

Isso derruba também as sessões legítimas de outras instâncias que usam a mesma role. Elas pegam credencial nova no IMDS automaticamente, então o impacto costuma ser só alguns erros por alguns minutos.

Se a instância tinha access key em arquivo (~/.aws/credentials, .env, variável de app), desative todas agora:

aws iam list-access-keys --user-name <USUARIO> 
aws iam update-access-key --user-name <USUARIO> --access-key-id <AKIA...> --status Inactive

7. Passo 4: O que o atacante fez com as credenciais

Para credenciais de instance role, o nome da sessão é o ID da instância. Isso facilita muito a busca:

aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=Username,AttributeValue="$IID" \
  --start-time "$(date -u -d '-90 days' +%FT%TZ)" \
  --max-items 5000 \
  --query 'Events[].CloudTrailEvent' --output text \
  | jq -r '[.eventTime, .awsRegion, .eventSource, .eventName, .sourceIPAddress, (.errorCode // "ok")] | @tsv' \
  | sort > "cloudtrail-${IID}.tsv"

O que procurar no resultado:

sourceIPAddress que não é IP da AWS nem da própria instância. Isso é a credencial sendo usada de fora.
ConsoleLogin ou GetFederationToken: o atacante transformou a credencial em sessão de console.
CreateUser, CreateAccessKey, AttachUserPolicy, CreateLoginProfile: persistência.
RunInstances em outras regiões: mais mineradores.
PutBucketPolicy, GetObject em massa: exfiltração.
Muitos AccessDenied seguidos: reconhecimento, tentando descobrir o que a role pode fazer.

O lookup-events só cobre 90 dias e só eventos de gerenciamento, e roda por região. Se o trail da organização manda para S3, faça a busca no Athena ou no CloudTrail Lake, em todas as regiões.

Varredura rápida de recursos criados em todas as regiões:

for r in $(aws ec2 describe-regions --query 'Regions[].RegionName' --output text); do
  echo "== $r"
  aws ec2 describe-instances --region "$r" \
    --query 'Reservations[].Instances[].[InstanceId,State.Name,LaunchTime,InstanceType]' --output text
done

Qualquer usuário IAM, access key ou instância que apareça e ninguém reconhece: desative, anote e não apague ainda. Apagar perde evidência.

8. Passo 5: Coletar dados voláteis

Com a rede isolada e o SSM funcionando, rode a coleta. Ela escreve no disco da própria instância, calcula hash e manda para o bucket de evidências. Isso altera um pouco o estado da máquina, é inevitável, e por isso fica registrado.

coleta.sh:

#!/bin/bash
set -u
CASO="$1"; BUCKET="$2"
OUT="/root/ir-${CASO}"; mkdir -p "$OUT"; cd "$OUT"

date -u +%FT%TZ          > 00-inicio.txt
uname -a                 > 01-uname.txt
uptime                   > 02-uptime.txt
ps auxwwf                > 10-ps.txt
ls -la /proc/*/exe 2>/dev/null > 11-proc-exe.txt
for p in /proc/[0-9]*; do
  echo "$(basename "$p") $(tr '\0' ' ' < "$p/cmdline" 2>/dev/null)"
done                     > 12-cmdlines.txt
ss -tunap                > 20-conexoes.txt
ip a; ip r               > 21-rede.txt 2>&1
cat /etc/ld.so.preload   > 30-ld-preload.txt 2>&1
crontab -l -u root       > 31-cron-root.txt 2>&1
ls -la /etc/cron* /var/spool/cron* > 32-cron-dirs.txt 2>&1
systemctl list-units --type=service --all > 33-services.txt
find /etc/systemd /lib/systemd /usr/lib/systemd -newermt "-60 days" -type f > 34-systemd-recentes.txt 2>/dev/null
find /tmp /var/tmp /dev/shm -xdev -type f -exec ls -la {} \; > 40-tmp.txt 2>/dev/null
cat /root/.ssh/authorized_keys /home/*/.ssh/authorized_keys > 41-authorized-keys.txt 2>&1
last -Faiw               > 50-last.txt 2>&1
lastb -Faiw              > 51-lastb.txt 2>&1
cp -a /var/log           ./var-log 2>/dev/null
cp /root/.bash_history /home/*/.bash_history ./ 2>/dev/null

date -u +%FT%TZ > 99-fim.txt
cd /root && tar czf "ir-${CASO}.tgz" "ir-${CASO}"
sha256sum "ir-${CASO}.tgz" | tee "ir-${CASO}.tgz.sha256"
aws s3 cp "ir-${CASO}.tgz"        "s3://${BUCKET}/${CASO}/"
aws s3 cp "ir-${CASO}.tgz.sha256" "s3://${BUCKET}/${CASO}/"

A instância precisa de permissão s3:PutObject no bucket de evidências. Como a role foi bloqueada no passo 3 (a deny vale só para tokens antigos, os novos funcionam), confirme que a role tem essa permissão ou anexe temporariamente uma policy só para o prefixo do caso.

Envio pelo Run Command:

aws s3 cp coleta.sh "s3://${BUCKET_EVID}/scripts/coleta.sh"

CMD_ID=$(aws ssm send-command --instance-ids "$IID" \
  --document-name AWS-RunShellScript \
  --parameters "commands=[\"aws s3 cp s3://${BUCKET_EVID}/scripts/coleta.sh /root/coleta.sh\",\"bash /root/coleta.sh ${CASO} ${BUCKET_EVID}\"]" \
  --output-s3-bucket-name "$BUCKET_EVID" --output-s3-key-prefix "${CASO}/ssm" \
  --query 'Command.CommandId' --output text)

aws ssm get-command-invocation --command-id "$CMD_ID" --instance-id "$IID" \
  --query '{status:Status,saida:StandardOutputContent}'

8.1 Memória

Para captura de RAM, o caminho mais simples hoje é o AVML (binário estático, não precisa compilar módulo de kernel como o LiME):

Baixe o binário numa máquina limpa e suba para o bucket de evidências antes (https://github.com/microsoft/avml/releases). Na instância, que está isolada, copie de lá:

aws s3 cp s3://${BUCKET_EVID}/tools/avml /root/avml
chmod +x /root/avml
/root/avml --compress /root/mem-${CASO}.lime.compressed
sha256sum /root/mem-${CASO}.lime.compressed
aws s3 cp /root/mem-${CASO}.lime.compressed s3://${BUCKET_EVID}/${CASO}/

A imagem de memória tem o tamanho da RAM, então confirme espaço em disco antes.

Rootkit de usuário. Se o /etc/ld.so.preload não está vazio, os comandos ps, ls e ss da própria máquina podem estar mentindo. A coleta continua valendo (ela registra o próprio arquivo), mas a análise confiável é a do snapshot montado em outra máquina, e a da memória.

9. Passo 6: Snapshots e envio para a conta de forense

VOLS=$(aws ec2 describe-instances --instance-ids "$IID" \
  --query 'Reservations[0].Instances[0].BlockDeviceMappings[].Ebs.VolumeId' --output text)

for v in $VOLS; do
  aws ec2 create-snapshot --volume-id "$v" \
    --description "${CASO} ${IID} ${v}" \
    --tag-specifications "ResourceType=snapshot,Tags=[{Key=Incidente,Value=${CASO}}]" \
    --query SnapshotId --output text
done

Compartilhar com a conta de forense:

Volume sem criptografia: modify-snapshot-attribute com createVolumePermission para a conta de forense.
Criptografado com a chave padrão aws/ebs: não dá para compartilhar. Faça copy-snapshot recriptografando com uma CMK sua, dê kms:Decrypt, kms:CreateGrant e kms:DescribeKey dessa CMK para a conta de forense e compartilhe a cópia.

aws ec2 copy-snapshot --source-region "$AWS_REGION" --source-snapshot-id <SNAP_ID> \
  --encrypted --kms-key-id <ARN_CMK_FORENSE> --description "${CASO} copia forense"

aws ec2 modify-snapshot-attribute --snapshot-id <SNAP_COPIA> \
  --attribute createVolumePermission --operation-type add \
  --user-ids <ACCOUNT_FORENSE>

10. Passo 7: Análise do disco

Na conta de forense, suba uma EC2 de análise numa subnet sem internet, crie um volume a partir do snapshot na mesma AZ e anexe. Monte somente leitura e sem replay de journal. Sem noload, o ext4 aplica o journal ao montar e altera o disco que você quer analisar:

lsblk
sudo mkdir -p /mnt/evid

# ext4
sudo mount -o ro,noload,noexec,nosuid,nodev /dev/nvme1n1p1 /mnt/evid

# xfs (Amazon Linux 2/2023 e RHEL usam xfs)
sudo mount -o ro,norecovery,nouuid,noexec,nosuid,nodev /dev/nvme1n1p1 /mnt/evid

O nouuid no xfs é porque o volume analisado costuma ter o mesmo UUID do disco raiz da máquina de análise, se as duas vieram da mesma AMI.

10.1 Linha do tempo

sudo find /mnt/evid -xdev -newermt "<DATA_INICIO_SUSPEITA>" \
  -printf '%TY-%Tm-%Td %TH:%TM:%TS %u %m %p\n' 2>/dev/null \
  | sort > timeline.txt

grep -E "/tmp/|/dev/shm|/var/tmp|/\.[^/]+$|cron|systemd/system|authorized_keys|ld.so.preload" timeline.txt

10.2 O minerador

# Config do XMRig e derivados
sudo grep -rIl --exclude-dir={proc,sys} -E '"(pool|url)"\s*:\s*".*:[0-9]{4,5}"|stratum\+tcp|donate-level' /mnt/evid 2>/dev/null

# Binarios ELF em diretorios onde nao deveriam existir
sudo find /mnt/evid/tmp /mnt/evid/var/tmp /mnt/evid/dev/shm /mnt/evid/root /mnt/evid/home \
  -type f -exec file {} \; 2>/dev/null | grep ELF

# Persistencia
sudo cat /mnt/evid/etc/ld.so.preload 2>/dev/null
sudo ls -la /mnt/evid/etc/cron.d /mnt/evid/var/spool/cron/ /mnt/evid/var/spool/cron/crontabs 2>/dev/null
sudo grep -rl -E "curl|wget|base64 -d|/tmp/|/dev/shm" /mnt/evid/etc/systemd /mnt/evid/etc/cron* /mnt/evid/etc/rc.local 2>/dev/null

Calcule o SHA-256 dos binários suspeitos e consulte em base pública de malware. Não execute nada.

10.3 Por onde entrou

Os vetores que mais aparecem nesse tipo de caso:

Vetor	Onde olhar
SSH com senha fraca	`/var/log/auth.log` ou `/var/log/secure`: muitos `Failed password` e depois um `Accepted password`
PostgreSQL exposto com `COPY ... FROM PROGRAM`	Log do Postgres procurando `FROM PROGRAM`, e `pg_hba.conf` aceitando `0.0.0.0/0`
Redis sem senha	`CONFIG SET dir` e escrita em `authorized_keys` ou cron
Aplicação web vulnerável	Access log do Nginx/Apache próximo ao horário do primeiro arquivo malicioso
Docker API exposta (2375)	Containers e imagens estranhas, `/var/lib/docker`

sudo grep -h "Accepted" /mnt/evid/var/log/auth.log* /mnt/evid/var/log/secure* 2>/dev/null | tail -50
sudo grep -rh -i "from program" /mnt/evid/var/lib/pgsql /mnt/evid/var/log/postgresql 2>/dev/null | head

Cruze o horário do primeiro acesso com o primeiro arquivo malicioso na timeline e com o primeiro evento de fora da AWS no CloudTrail do passo 4. Quando os três batem, você tem a história.

10.4 Roubo de credencial pelo IMDS

Se o GuardDuty acusou exfiltração, procure como o atacante chegou no metadata:

sudo grep -rh "169.254.169.254" /mnt/evid/root/.bash_history /mnt/evid/home/*/.bash_history /mnt/evid/tmp 2>/dev/null

E confira a configuração da instância. IMDSv2 dificulta SSRF, mas não impede quem já tem shell na máquina. Quem tem shell faz o PUT do token e pega a credencial do mesmo jeito.

aws ec2 describe-instances --instance-ids "$IID" \
  --query 'Reservations[0].Instances[0].MetadataOptions'

11. Passo 8: Erradicar e reconstruir

Não "limpe" a instância. Não dá para ter certeza de que tudo saiu.

Suba uma instância nova a partir de AMI oficial ou da sua pipeline de imagem, nunca de AMI criada a partir da comprometida.
Restaure dados de um backup anterior à data de entrada, validado.
Troque todos os segredos que existiam na máquina: senhas de banco, tokens de API, chaves SSH, certificados, variáveis de ambiente da aplicação.
Remova a política de deny do passo 3 só depois de confirmar que não existe credencial persistente criada pelo atacante.
Apague usuários, chaves e instâncias criados pelo atacante, depois de documentar.
Mantenha a instância isolada e os snapshots pelo prazo que o jurídico ou o contrato pedirem.

12. Passo 9: Para não acontecer de novo

# IMDSv2 obrigatorio e hop limit 1 (container nao alcanca o IMDS do host)
aws ec2 modify-instance-metadata-options --instance-id <NOVA_INSTANCIA> \
  --http-tokens required --http-put-response-hop-limit 1

# Padrao da conta para instancias novas
aws ec2 modify-instance-metadata-defaults --http-tokens required --http-put-response-hop-limit 1

Restrinja o uso da credencial da role ao lugar de onde ela deveria vir. A condição abaixo, numa SCP ou na própria policy, nega uso fora da VPC da instância:

{
  "Effect": "Deny",
  "Action": "*",
  "Resource": "*",
  "Condition": {
    "StringNotEquals": { "aws:EC2InstanceSourceVPC": "${aws:SourceVpc}" },
    "Null": { "aws:ec2InstanceSourceVPC": "false" },
    "BoolIfExists": { "aws:ViaAWSService": "false" }
  }
}

Essa regra depende do aws:SourceVpc, que só existe quando a chamada passa por VPC endpoint. Então ela funciona bem em VPC que acessa os serviços por endpoint (STS, S3, SSM etc.). Sem endpoint, use a variação com aws:EC2InstanceSourcePrivateIPv4 e aws:VpcSourceIp, que está na mesma documentação. Teste em uma conta de homologação antes: serviços que chamam outros serviços em seu nome podem cair nessa regra.

Checklist:

[ ] Nenhum SG com 22, 3389, 5432, 3306, 6379, 2375 ou 9200 aberto para 0.0.0.0/0
[ ] Acesso administrativo só por SSM Session Manager
[ ] No PostgreSQL, ninguém além do DBA com pg_execute_server_program ou superuser
[ ] GuardDuty com Runtime Monitoring habilitado em todas as regiões
[ ] Alarme de CPUUtilization alto e prolongado em instâncias que não deveriam ter carga constante
[ ] VPC Flow Logs habilitados e retidos
[ ] CloudTrail da organização para S3 com retenção longa
[ ] Alerta de billing por região

13. Referências

AWS Security Incident Response Guide: https://docs.aws.amazon.com/whitepapers/latest/aws-security-incident-response-guide/welcome.html
Connection tracking em security groups: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-connection-tracking.html
Revogar sessões de role: https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_revoke-sessions.html
Findings do GuardDuty para EC2: https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_finding-types-ec2.html
AVML: https://github.com/microsoft/avml
Condition keys de credencial de instância: https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html

Athena via ODBC sem access key: IAM Roles Anywhere para Power BI e Excel fora da AWS

Railander Marques — Thu, 12 Nov 2026 12:24:28 +0000

1. Objetivo

Liberar acesso ao Amazon Athena via driver ODBC (Power BI, Excel, DBeaver, qualquer coisa que fale ODBC) a partir de máquinas fora da AWS, sem criar access key e sem depender de IAM Identity Center. A máquina do usuário troca um certificado X.509 por credenciais temporárias de 1 hora através do IAM Roles Anywhere. O signing helper fica rodando em segundo plano e mantém essas credenciais sempre renovadas num profile do arquivo credentials, que é de onde o driver lê.

Resultado esperado:

Nenhuma access key fixa existe na conta para esse acesso.
Cada usuário tem o próprio certificado, com validade curta (o tempo do projeto).
A role só enxerga um workgroup do Athena e os dados que precisa.
No CloudTrail dá para saber qual certificado fez cada consulta.
Encerrar o acesso de todo mundo é um comando.

2. Por que não access key (e por que não Identity Center)

Opção	Problema
Usuário IAM + access key	Credencial de longa duração parada num arquivo da máquina de alguém. Vaza, ninguém percebe, ninguém rotaciona.
IAM Identity Center	Ótimo quando existe. Mas nem sempre dá para usar: a organização pode ser só interna, o usuário pode ser de outra empresa, e o driver precisa de fluxo de navegador configurado.
Cognito + federação	Funciona, mas é muita peça para um acesso que vai durar semanas.
IAM Roles Anywhere	Credencial temporária, validade amarrada ao certificado, sem usuário IAM. O custo é gerenciar uma CA pequena.

Esse cenário aparece muito em projeto de dashboard: o time do cliente precisa conectar o Power BI direto no Athena durante a construção, e depois o acesso acaba. Roles Anywhere encaixa bem nisso porque o próprio certificado já carrega a data de fim.

3. Arquitetura

 Maquina do usuario (Windows)
 +--------------------------------------------------+
 |  Power BI / Excel                                |
 |      |                                           |
 |  Driver ODBC Athena 2.x  (Auth: IAM Profile)     |
 |      ^  le ~/.aws/credentials [athena-odbc]    |
 |      |                                           |
 |  aws_signing_helper.exe update (segundo plano)   |
 |      |  assina com usuario.key + usuario.pem     |
 +------|-------------------------------------------+
        | HTTPS
        v
 IAM Roles Anywhere  --valida contra-->  Trust anchor (CA propria)
        |
        | credenciais temporarias (1h)
        v
 Athena (workgroup dedicado) --> Glue Data Catalog --> S3 (dados) / S3 (resultados)

4. Pré-requisitos

[ ] Dados já catalogados no Glue e consultáveis pelo Athena
[ ] OpenSSL na máquina onde a CA vai ficar (não na máquina do usuário)
[ ] Driver ODBC do Athena versão 2.x na máquina do usuário
[ ] AWS CLI v2 na sua máquina

export AWS_REGION="us-east-1"
export ACCOUNT_ID="<ACCOUNT_ID>"
export WORKGROUP="wg-dashboards"
export BUCKET_DADOS="<BUCKET_DADOS>"
export BUCKET_RESULTADOS="<BUCKET_RESULTADOS_ATHENA>"
export GLUE_DB="<DATABASE_GLUE>"

5. Passo 1: Workgroup dedicado

Um workgroup só para esse acesso, com local de resultado forçado e limite de bytes escaneados por consulta. O limite evita que um SELECT * sem filtro numa tabela grande vire uma fatura surpresa.

aws athena create-work-group --name "$WORKGROUP" \
  --configuration "ResultConfiguration={OutputLocation=s3://${BUCKET_RESULTADOS}/${WORKGROUP}/},EnforceWorkGroupConfiguration=true,PublishCloudWatchMetricsEnabled=true,BytesScannedCutoffPerQuery=10737418240" \
  --description "Acesso ODBC externo via Roles Anywhere"

10737418240 é 10 GB por consulta. Ajuste ao tamanho dos seus dados.

Com EnforceWorkGroupConfiguration=true, o usuário não consegue mandar o resultado para outro bucket, mesmo que configure isso no driver.

6. Passo 2: CA e trust anchor

6.1 CA

mkdir -p ~/ca-rolesanywhere/{private,usuarios} && cd ~/ca-rolesanywhere
chmod 700 private

cat > ca.cnf <<'EOF'
[ req ]
distinguished_name = dn
prompt = no
x509_extensions = ext_ca
[ dn ]
CN = CA Acesso Athena
O  = <SUA_ORG>
C  = BR
[ ext_ca ]
basicConstraints = critical, CA:true
keyUsage = critical, keyCertSign, cRLSign
subjectKeyIdentifier = hash
EOF

openssl genrsa -out private/ca.key 4096
chmod 400 private/ca.key
openssl req -new -x509 -days 1825 -config ca.cnf -key private/ca.key -out ca.pem

6.2 Trust anchor

jq -n --arg pem "$(cat ca.pem)" \
  '{sourceType:"CERTIFICATE_BUNDLE", sourceData:{x509CertificateData:$pem}}' > source.json

TA_ARN=$(aws rolesanywhere create-trust-anchor \
  --name ta-athena-odbc \
  --source file://source.json \
  --enabled \
  --query 'trustAnchor.trustAnchorArn' --output text)

echo "$TA_ARN"

Se a CA tiver custo de gestão que você não quer, a alternativa é o AWS Private CA como fonte do trust anchor. Funciona sem OpenSSL na emissão, mas tem custo mensal fixo. Para acesso de poucas semanas, a CA local resolve.

7. Passo 3: Role com trust policy restrita

O Roles Anywhere transforma o subject do certificado em session tags (x509Subject/CN, x509Subject/OU etc.). Isso permite que a trust policy aceite só certificados de um OU específico, mesmo que a CA emita certificados para outros fins.

trust-ra.json:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": { "Service": "rolesanywhere.amazonaws.com" },
      "Action": ["sts:AssumeRole", "sts:TagSession", "sts:SetSourceIdentity"],
      "Condition": {
        "ArnEquals": {
          "aws:SourceArn": "arn:aws:rolesanywhere:us-east-1:<ACCOUNT_ID>:trust-anchor/<TRUST_ANCHOR_ID>"
        },
        "StringEquals": {
          "aws:PrincipalTag/x509Subject/OU": "athena-odbc"
        }
      }
    }
  ]
}

Permissões (policy-athena.json). O que mais esquecem: o PutObject no bucket de resultados e o kms:Decrypt se os dados usam SSE-KMS.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AthenaWorkgroup",
      "Effect": "Allow",
      "Action": [
        "athena:StartQueryExecution",
        "athena:StopQueryExecution",
        "athena:GetQueryExecution",
        "athena:GetQueryResults",
        "athena:GetQueryResultsStream",
        "athena:ListQueryExecutions",
        "athena:GetWorkGroup"
      ],
      "Resource": "arn:aws:athena:us-east-1:<ACCOUNT_ID>:workgroup/wg-dashboards"
    },
    {
      "Sid": "AthenaMetadados",
      "Effect": "Allow",
      "Action": [
        "athena:ListWorkGroups",
        "athena:ListDataCatalogs",
        "athena:GetDataCatalog",
        "athena:ListDatabases",
        "athena:GetDatabase",
        "athena:ListTableMetadata",
        "athena:GetTableMetadata"
      ],
      "Resource": "*"
    },
    {
      "Sid": "Glue",
      "Effect": "Allow",
      "Action": [
        "glue:GetDatabase",
        "glue:GetDatabases",
        "glue:GetTable",
        "glue:GetTables",
        "glue:GetPartition",
        "glue:GetPartitions",
        "glue:BatchGetPartition"
      ],
      "Resource": [
        "arn:aws:glue:us-east-1:<ACCOUNT_ID>:catalog",
        "arn:aws:glue:us-east-1:<ACCOUNT_ID>:database/<DATABASE_GLUE>",
        "arn:aws:glue:us-east-1:<ACCOUNT_ID>:table/<DATABASE_GLUE>/*"
      ]
    },
    {
      "Sid": "LeituraDados",
      "Effect": "Allow",
      "Action": ["s3:GetObject", "s3:ListBucket", "s3:GetBucketLocation"],
      "Resource": [
        "arn:aws:s3:::<BUCKET_DADOS>",
        "arn:aws:s3:::<BUCKET_DADOS>/*"
      ]
    },
    {
      "Sid": "Resultados",
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:PutObject",
        "s3:ListBucket",
        "s3:GetBucketLocation",
        "s3:AbortMultipartUpload",
        "s3:ListMultipartUploadParts"
      ],
      "Resource": [
        "arn:aws:s3:::<BUCKET_RESULTADOS_ATHENA>",
        "arn:aws:s3:::<BUCKET_RESULTADOS_ATHENA>/wg-dashboards/*"
      ]
    }
  ]
}

Se os dados estão sob Lake Formation, a parte de S3 de dados sai e entra lakeformation:GetDataAccess mais o grant da role na tabela pelo Lake Formation. Sem o grant, o erro é Insufficient Lake Formation permission(s), mesmo com a policy IAM certa.

aws iam create-role --role-name ra-athena-odbc \
  --assume-role-policy-document file://trust-ra.json \
  --max-session-duration 3600

aws iam put-role-policy --role-name ra-athena-odbc \
  --policy-name athena-wg-dashboards \
  --policy-document file://policy-athena.json

8. Passo 4: Profile do Roles Anywhere

ROLE_ARN="arn:aws:iam::${ACCOUNT_ID}:role/ra-athena-odbc"

PROFILE_ARN=$(aws rolesanywhere create-profile \
  --name prof-athena-odbc \
  --role-arns "$ROLE_ARN" \
  --duration-seconds 3600 \
  --enabled \
  --query 'profile.profileArn' --output text)

echo "$PROFILE_ARN"

O profile também aceita --managed-policy-arns e --session-policy, que funcionam como teto em cima da role. Útil se a mesma role atende mais de um perfil de uso.

9. Passo 5: Emitir o certificado do usuário

A validade do certificado é o prazo do acesso. Projeto de 45 dias, certificado de 45 dias.

#!/usr/bin/env bash
set -euo pipefail
USUARIO="$1"     # ex.: analista-01
DIAS="${2:-45}"
cd ~/ca-rolesanywhere

cat > "usuarios/${USUARIO}.ext" <<'EOF'
basicConstraints = critical, CA:false
keyUsage = critical, digitalSignature
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid
EOF

openssl genrsa -out "usuarios/${USUARIO}.key" 2048
openssl req -new -key "usuarios/${USUARIO}.key" \
  -subj "/CN=${USUARIO}/OU=athena-odbc/O=<SUA_ORG>/C=BR" \
  -out "usuarios/${USUARIO}.csr"

openssl x509 -req -in "usuarios/${USUARIO}.csr" \
  -CA ca.pem -CAkey private/ca.key -CAcreateserial \
  -days "$DIAS" -sha256 -extfile "usuarios/${USUARIO}.ext" \
  -out "usuarios/${USUARIO}.pem"

rm -f "usuarios/${USUARIO}.csr" "usuarios/${USUARIO}.ext"
openssl x509 -in "usuarios/${USUARIO}.pem" -noout -subject -serial -enddate

Guarde numa planilha a relação serial, usuário, data de fim. O serial é o que aparece no CloudTrail.

O OU=athena-odbc é o que a trust policy do passo 3 exige. Certificado sem esse OU não assume a role, mesmo vindo da mesma CA.

10. Passo 6: Configurar a máquina do usuário (Windows)

10.1 Signing helper

Baixe o aws_signing_helper.exe da página de documentação do Roles Anywhere (seção "Obtaining temporary security credentials") e coloque em C:\aws\. Coloque o .pem e o .key em C:\aws\certs\ e restrinja a pasta ao próprio usuário:

New-Item -ItemType Directory -Force C:\aws\certs | Out-Null
icacls C:\aws\certs /inheritance:r /grant:r "$($env:USERNAME):(OI)(CI)F"

Teste o helper sozinho antes de mexer no ODBC. Se isso não devolver JSON com AccessKeyId, nada depois vai funcionar:

C:\aws\aws_signing_helper.exe credential-process `
  --certificate C:\aws\certs\analista-01.pem `
  --private-key C:\aws\certs\analista-01.key `
  --trust-anchor-arn <TRUST_ANCHOR_ARN> `
  --profile-arn <PROFILE_ARN> `
  --role-arn <ROLE_ARN>

10.2 Manter as credenciais renovadas no `credentials`

Por que não credential_process no config: é o caminho mais comum com AWS CLI e SDKs, mas a documentação do IAM Profile do driver ODBC 2.x só cita credential_source (Ec2InstanceMetadata, EcsContainer, Environment) e plugin_name. Não dá para contar com credential_process ali. O que o driver garante é ler o profile do arquivo credentials e, nas versões mais novas, recarregar quando o arquivo muda.

Então o helper roda no modo update: ele escreve credenciais temporárias no profile athena-odbc do %USERPROFILE%\.aws\credentials e reescreve antes de expirar.

%USERPROFILE%\.aws\config:

[profile athena-odbc]
region = us-east-1

Script C:\aws\athena-cred.ps1:

& C:\aws\aws_signing_helper.exe update `
  --profile athena-odbc `
  --certificate C:\aws\certs\analista-01.pem `
  --private-key C:\aws\certs\analista-01.key `
  --trust-anchor-arn <TRUST_ANCHOR_ARN> `
  --profile-arn <PROFILE_ARN> `
  --role-arn <ROLE_ARN>

Para não depender de alguém lembrar de abrir, registre como tarefa agendada no logon do usuário:

$acao = New-ScheduledTaskAction -Execute "powershell.exe" `
  -Argument "-NoProfile -WindowStyle Hidden -File C:\aws\athena-cred.ps1"
$gatilho = New-ScheduledTaskTrigger -AtLogOn -User $env:USERNAME
Register-ScheduledTask -TaskName "athena-roles-anywhere" -Action $acao -Trigger $gatilho
Start-ScheduledTask -TaskName "athena-roles-anywhere"

Confira que o profile apareceu no %USERPROFILE%\.aws\credentials com aws_access_key_id, aws_secret_access_key e aws_session_token. Essas chaves são temporárias e valem 1 hora; o helper troca sozinho.

Se a máquina tiver AWS CLI:

aws sts get-caller-identity --profile athena-odbc

O Arn volta como assumed-role/ra-athena-odbc/<SERIAL>.

Chave privada fora de arquivo. O signing helper também lê do repositório de certificados do Windows com --cert-selector, no lugar de --certificate e --private-key. Se importar o .pfx marcando a chave como não exportável, o arquivo .key deixa de existir no disco. Vale para acesso mais longo. Para um acesso de semanas, a pasta com ACL resolve.

10.3 DSN ODBC

Abra o ODBC Data Sources (64-bit) (Power BI Desktop é 64 bits; usar o de 32 é o erro número um aqui) e crie um System DSN com o driver Amazon Athena ODBC (x64):

Campo	Valor
Data Source Name	`Athena-Dashboards`
Region	`us-east-1`
Catalog	`AwsDataCatalog`
Database	`<DATABASE_GLUE>`
Workgroup	`wg-dashboards`
S3 Output Location	em branco (o workgroup força)
Authentication Type	`IAM Profile`
AWS Profile	`athena-odbc`

Clique em Test. Se der certo, no Power BI use Obter dados → ODBC → Athena-Dashboards.

Gateway on-premises do Power BI. O gateway roda como serviço (PBIEgwService), não como o usuário logado. Ele não lê o %USERPROFILE%\.aws de ninguém. Nesse caso aponte o update para um arquivo fixo com a variável AWS_SHARED_CREDENTIALS_FILE=C:\aws\credentials (no ambiente da tarefa agendada e como variável de sistema), faça o mesmo com AWS_CONFIG_FILE=C:\aws\config, dê leitura na pasta para a conta do serviço e reinicie o gateway. Esse detalhe consome uma tarde se ninguém avisar.

11. Passo 7: Rastrear quem consultou o quê

Por padrão, o nome da sessão é o serial do certificado. No CloudTrail:

aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=EventName,AttributeValue=StartQueryExecution \
  --max-results 20 \
  --query 'Events[].CloudTrailEvent' --output text \
  | jq -r 'select(.userIdentity.arn | contains("ra-athena-odbc")) | [.eventTime, .userIdentity.arn, .sourceIPAddress] | @tsv'

Cruzando o serial com a planilha do passo 5, você tem usuário, horário e IP de origem. O texto da consulta fica no histórico do workgroup (aws athena list-query-executions --work-group wg-dashboards).

Para ver o consumo do workgroup:

aws cloudwatch get-metric-statistics --namespace AWS/Athena \
  --metric-name ProcessedBytes --dimensions Name=WorkGroup,Value=wg-dashboards \
  --start-time "$(date -u -d '-7 days' +%FT%TZ)" --end-time "$(date -u +%FT%TZ)" \
  --period 86400 --statistics Sum

12. Passo 8: Encerrar o acesso

Tem três níveis, do mais pontual ao mais amplo:

Um usuário só, antes do certificado vencer: gere uma CRL com o serial dele e importe no Roles Anywhere. Como a CA do passo 2 é simples (sem o banco do openssl ca), monte um índice mínimo só para gerar a CRL:

cd ~/ca-rolesanywhere
SERIAL=$(openssl x509 -in usuarios/analista-01.pem -noout -serial | cut -d= -f2)
REVOGADO_EM=$(date -u +%y%m%d%H%M%SZ)
VENCE_EM=$(openssl x509 -in usuarios/analista-01.pem -noout -enddate | cut -d= -f2 \
  | xargs -I{} date -u -d "{}" +%y%m%d%H%M%SZ)

mkdir -p crl && touch crl/index.txt && echo 1000 > crl/crlnumber
printf 'R\t%s\t%s\t%s\tunknown\t/CN=analista-01\n' "$VENCE_EM" "$REVOGADO_EM" "$SERIAL" >> crl/index.txt

cat > crl.cnf <<'EOF'
[ ca ]
default_ca = ca_crl
[ ca_crl ]
database         = crl/index.txt
crlnumber        = crl/crlnumber
default_md       = sha256
default_crl_days = 30
EOF

openssl ca -config crl.cnf -gencrl -keyfile private/ca.key -cert ca.pem -out crl.pem
openssl crl -in crl.pem -noout -text | grep -A1 "Serial Number"

aws rolesanywhere import-crl --name crl-athena-odbc \
  --trust-anchor-arn "$TA_ARN" \
  --crl-data fileb://crl.pem --enabled

Todo mundo, temporariamente:

aws rolesanywhere disable-profile --profile-id <PROFILE_ID>

Fim do projeto:

aws rolesanywhere delete-profile --profile-id <PROFILE_ID>
aws rolesanywhere delete-trust-anchor --trust-anchor-id <TRUST_ANCHOR_ID>
aws iam delete-role-policy --role-name ra-athena-odbc --policy-name athena-wg-dashboards
aws iam delete-role --role-name ra-athena-odbc

Credenciais já emitidas continuam válidas até expirar (no máximo 1 hora, pela configuração do profile). Se precisar cortar na hora, use Revoke active sessions na role pelo console, que adiciona uma deny por aws:TokenIssueTime.

13. Troubleshooting

Sintoma	Causa provável	Ação
Helper retorna `AccessDeniedException`	OU do certificado não bate com a trust policy, ou trust anchor errado no ARN	`openssl x509 -noout -subject` e conferir `aws:SourceArn`
Helper retorna erro de assinatura	`.pem` e `.key` não são par	Comparar `openssl x509 -noout -modulus` e `openssl rsa -noout -modulus`
DSN testa ok, Power BI não lista tabelas	Falta `glue:GetTables` ou grant no Lake Formation	Policy do passo 3
`Access denied when writing output`	Falta `PutObject` no prefixo do workgroup	Policy de resultados
Funciona no Desktop, falha no gateway	Gateway roda como serviço	`AWS_SHARED_CREDENTIALS_FILE` e `AWS_CONFIG_FILE` de sistema
Funciona e para de funcionar depois de 1 hora	Helper `update` não está rodando	Tarefa agendada e `Get-ScheduledTask athena-roles-anywhere`
`Query exhausted resources` ou corte por bytes	Limite do workgroup	Partições no filtro ou aumentar o limite
Driver não acha o profile	DSN de 32 bits ou profile com nome diferente	ODBC 64-bit, `[profile athena-odbc]`

14. Referências

IAM Roles Anywhere: https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html
Signing helper: https://docs.aws.amazon.com/rolesanywhere/latest/userguide/credential-helper.html
Mapeamento de atributos do certificado: https://docs.aws.amazon.com/rolesanywhere/latest/userguide/attribute-mapping.html
Athena ODBC 2.x, autenticação: https://docs.aws.amazon.com/athena/latest/ug/odbc-v2-driver-authentication-options.html
Controle de custo por workgroup: https://docs.aws.amazon.com/athena/latest/ug/workgroups-setting-control-limits-cloudwatch.html

ALB com mTLS e CA própria: expondo um serviço interno só para parceiros com certificado

Railander Marques — Thu, 12 Nov 2026 12:24:27 +0000

1. Objetivo

Expor um serviço interno (no exemplo, um GitLab que fica atrás de VPN) para um conjunto pequeno de parceiros externos, sem abrir para a internet e sem exigir VPN de pipeline de CI. A porta de entrada é um Application Load Balancer público com mutual TLS em modo verify: só completa o handshake quem apresenta um certificado de cliente emitido pela nossa CA.

Resultado esperado:

Sem certificado: a conexão nem chega no HTTP, o ALB derruba no handshake.
Com certificado válido: a requisição chega no GitLab, com os dados do certificado nos headers.
Cada parceiro tem o próprio certificado e só enxerga o caminho dele.
Revogar um parceiro é subir uma CRL, sem mexer nos outros.

O caso real que motivou isso: pipelines de clientes no GitHub Actions fazendo git push --mirror para o GitLab interno. Quando o GitLab foi para trás da VPN, o mirror parou. Liberar os IPs do GitHub Actions não é opção (são milhares e mudam), e colocar VPN no runner é complicado. mTLS no ALB resolve com pouca peça.

2. Conceitos

2.1 Passthrough vs verify

Modo	Quem valida o certificado	Quando usar
`off`	Ninguém	Padrão
`passthrough`	O backend. O ALB só repassa o certificado no header `X-Amzn-Mtls-Clientcert`	Quando a aplicação já sabe validar
`verify`	O próprio ALB, contra um trust store	Quando o backend não sabe (caso do GitLab atrás do ALB)

Aqui usamos verify. A validação acontece no ALB e o backend recebe só tráfego já autenticado.

2.2 O que o ALB manda para o backend em modo verify

Header	Conteúdo
`X-Amzn-Mtls-Clientcert-Subject`	Subject do certificado em RFC2253, ex.: `C=BR,O=Parceiros,CN=parceiro-a`
`X-Amzn-Mtls-Clientcert-Issuer`	Quem emitiu
`X-Amzn-Mtls-Clientcert-Serial-Number`	Serial em hex
`X-Amzn-Mtls-Clientcert-Validity`	`NotBefore` e `NotAfter`
`X-Amzn-Mtls-Clientcert-Leaf`	O certificado em PEM (URL encoded)

Esses headers também podem ser usados em regras do listener, e é isso que permite isolar um parceiro do outro sem tocar no backend.

2.3 Desenho

 GitHub Actions (parceiro A) ---+
   cert CN=parceiro-a            |   HTTPS 443 + certificado de cliente
                                 v
 GitHub Actions (parceiro B) --> ALB publico (mTLS verify) --> Target group --> GitLab (subnet privada)
   cert CN=parceiro-b            ^          |
                                 |          +-- trust store (CA + CRL no S3)
 Qualquer outro -----------------X  (handshake recusado)

3. Pré-requisitos

[ ] VPC com duas subnets públicas (ALB) e o serviço em subnet privada
[ ] Certificado de servidor no ACM para git-mirror.<SEU_DOMINIO>
[ ] Bucket S3 privado para o trust store
[ ] OpenSSL 1.1.1 ou superior na máquina onde a CA vai ficar
[ ] AWS CLI v2

export AWS_REGION="us-east-1"
export DOMINIO="git-mirror.<SEU_DOMINIO>"
export TS_BUCKET="<BUCKET_TRUSTSTORE>"
export VPC_ID="vpc-<ID>"
export SUBNETS_PUB="subnet-pub-a subnet-pub-b"
export ACM_ARN="arn:aws:acm:us-east-1:<ACCOUNT_ID>:certificate/<ID>"
export GITLAB_INSTANCE="i-<ID>"

4. Passo 1: Criar a CA

Uma CA simples com openssl ca. Usar openssl ca (e não só openssl x509 -req) dá mais trabalho no começo, mas é o que mantém o index.txt e permite gerar CRL depois. Sem isso, revogar vira dor de cabeça.

mkdir -p ~/ca-mtls/{certs,crl,newcerts,private,clientes}
cd ~/ca-mtls
chmod 700 private
touch index.txt
echo 1000 > serial
echo 1000 > crlnumber

openssl.cnf:

[ ca ]
default_ca = CA_mtls

[ CA_mtls ]
dir               = .
certs             = $dir/certs
crl_dir           = $dir/crl
new_certs_dir     = $dir/newcerts
database          = $dir/index.txt
serial            = $dir/serial
crlnumber         = $dir/crlnumber
private_key       = $dir/private/ca.key
certificate       = $dir/certs/ca.pem
crl               = $dir/crl/ca.crl
default_md        = sha256
default_days      = 365
default_crl_days  = 30
policy            = policy_parceiro
unique_subject    = no
copy_extensions   = none

[ policy_parceiro ]
commonName             = supplied
organizationName       = optional
countryName            = optional

[ req ]
distinguished_name = req_dn
prompt             = no

[ req_dn ]
CN = CA mTLS Parceiros
O  = <SUA_ORG>
C  = BR

[ ext_ca ]
basicConstraints       = critical, CA:true
keyUsage               = critical, keyCertSign, cRLSign
subjectKeyIdentifier   = hash

[ ext_cliente ]
basicConstraints       = critical, CA:false
keyUsage               = critical, digitalSignature, keyEncipherment
extendedKeyUsage       = clientAuth
subjectKeyIdentifier   = hash
authorityKeyIdentifier = keyid

Gerar a chave e o certificado da CA (10 anos):

openssl genrsa -out private/ca.key 4096
chmod 400 private/ca.key

openssl req -config openssl.cnf -new -x509 -days 3650 \
  -key private/ca.key -extensions ext_ca -out certs/ca.pem

openssl x509 -in certs/ca.pem -noout -subject -dates -ext basicConstraints,keyUsage

Guarde a ca.key fora da máquina de trabalho. Quem tem essa chave emite certificado aceito pelo ALB. No mínimo, cofre de senha com o arquivo cifrado ou um secret no Secrets Manager com acesso restrito a duas pessoas.

5. Passo 2: Emitir um certificado por parceiro

Script emitir.sh:

#!/usr/bin/env bash
set -euo pipefail
PARCEIRO="$1"   # ex.: parceiro-a
cd ~/ca-mtls

openssl genrsa -out "clientes/${PARCEIRO}.key" 2048
openssl req -new -key "clientes/${PARCEIRO}.key" \
  -subj "/CN=${PARCEIRO}/O=Parceiros/C=BR" \
  -out "clientes/${PARCEIRO}.csr"

openssl ca -config openssl.cnf -batch -extensions ext_cliente \
  -in "clientes/${PARCEIRO}.csr" -out "clientes/${PARCEIRO}.pem"

rm -f "clientes/${PARCEIRO}.csr"
openssl x509 -in "clientes/${PARCEIRO}.pem" -noout -subject -serial -enddate

chmod +x emitir.sh
./emitir.sh parceiro-a
./emitir.sh parceiro-b

Anote o serial de cada um. É ele que vai aparecer no header e no log de conexão do ALB, e é por ele que você vai saber quem fez o quê.

Entregue ao parceiro o .pem e o .key por canal seguro (link de uso único de cofre, nunca anexo de e-mail).

6. Passo 3: Trust store

aws s3 cp ~/ca-mtls/certs/ca.pem "s3://${TS_BUCKET}/truststore/ca-bundle.pem"

TS_ARN=$(aws elbv2 create-trust-store \
  --name ts-parceiros \
  --ca-certificates-bundle-s3-bucket "$TS_BUCKET" \
  --ca-certificates-bundle-s3-key truststore/ca-bundle.pem \
  --query 'TrustStores[0].TrustStoreArn' --output text)

echo "$TS_ARN"
aws elbv2 describe-trust-stores --trust-store-arns "$TS_ARN" \
  --query 'TrustStores[0].{status:Status,cas:NumberOfCaCertificates}'

O ALB lê o arquivo do S3 só no momento da criação ou da modificação. Trocar o arquivo no bucket depois não muda nada até você rodar modify-trust-store.

7. Passo 4: Target group

TG_ARN=$(aws elbv2 create-target-group \
  --name tg-gitlab-mirror \
  --protocol HTTP --port 80 \
  --vpc-id "$VPC_ID" \
  --target-type instance \
  --health-check-path "/-/readiness" \
  --matcher HttpCode=200 \
  --query 'TargetGroups[0].TargetGroupArn' --output text)

aws elbv2 register-targets --target-group-arn "$TG_ARN" --targets "Id=${GITLAB_INSTANCE}"

Health check do GitLab. Os endpoints /-/health, /-/readiness e /-/liveness só respondem 200 para IPs da monitoring_whitelist. O ALB chama de IP interno da VPC, então o target fica unhealthy com 404 até você liberar o CIDR no gitlab.rb e rodar gitlab-ctl reconfigure:
gitlab_rails['monitoring_whitelist'] = ['127.0.0.0/8', '<CIDR_DA_VPC>']

Ainda no gitlab.rb, como o TLS termina no ALB, informe o GitLab que ele está atrás de proxy HTTPS:

external_url 'https://git-mirror.<SEU_DOMINIO>'
nginx['listen_port']  = 80
nginx['listen_https'] = false
nginx['real_ip_trusted_addresses'] = ['<CIDR_DA_VPC>']
nginx['real_ip_header'] = 'X-Forwarded-For'

8. Passo 5: ALB e listener com mTLS

Security group do ALB: 443 aberto para 0.0.0.0/0. Parece estranho, mas a autenticação aqui é o certificado, não o IP. O SG da instância do GitLab aceita 80 só do SG do ALB.

SG_ALB=$(aws ec2 create-security-group --group-name sg-alb-mtls \
  --description "ALB mTLS parceiros" --vpc-id "$VPC_ID" --query GroupId --output text)
aws ec2 authorize-security-group-ingress --group-id "$SG_ALB" \
  --protocol tcp --port 443 --cidr 0.0.0.0/0

aws ec2 authorize-security-group-ingress --group-id <SG_GITLAB> \
  --protocol tcp --port 80 --source-group "$SG_ALB"

ALB_ARN=$(aws elbv2 create-load-balancer \
  --name alb-git-mirror \
  --type application --scheme internet-facing \
  --subnets $SUBNETS_PUB \
  --security-groups "$SG_ALB" \
  --query 'LoadBalancers[0].LoadBalancerArn' --output text)

Listener. A ação padrão é 404 fixo, e não forward. O tráfego só chega no GitLab pelas regras do passo 6:

LISTENER_ARN=$(aws elbv2 create-listener \
  --load-balancer-arn "$ALB_ARN" \
  --protocol HTTPS --port 443 \
  --ssl-policy ELBSecurityPolicy-TLS13-1-2-2021-06 \
  --certificates "CertificateArn=${ACM_ARN}" \
  --mutual-authentication "Mode=verify,TrustStoreArn=${TS_ARN},IgnoreClientCertificateExpiry=false" \
  --default-actions 'Type=fixed-response,FixedResponseConfig={StatusCode=404,ContentType=text/plain,MessageBody=nao encontrado}' \
  --query 'Listeners[0].ListenerArn' --output text)

Crie o registro DNS (CNAME ou alias Route 53) de git-mirror.<SEU_DOMINIO> para o DNS do ALB.

9. Passo 6: Isolar um parceiro do outro

O mTLS sozinho garante que só parceiros entram. Mas, sem regra, o parceiro A com certificado válido consegue tentar falar com o repositório do parceiro B. O GitLab ainda vai pedir token, mas é melhor que a requisição nem chegue.

Supondo grupos no GitLab parceiro-a/ e parceiro-b/:

aws elbv2 create-rule --listener-arn "$LISTENER_ARN" --priority 10 \
  --conditions '[
    {"Field":"http-header","HttpHeaderConfig":{"HttpHeaderName":"X-Amzn-Mtls-Clientcert-Subject","Values":["*CN=parceiro-a","CN=parceiro-a,*"]}},
    {"Field":"path-pattern","PathPatternConfig":{"Values":["/parceiro-a/*"]}}
  ]' \
  --actions "Type=forward,TargetGroupArn=${TG_ARN}"

aws elbv2 create-rule --listener-arn "$LISTENER_ARN" --priority 20 \
  --conditions '[
    {"Field":"http-header","HttpHeaderConfig":{"HttpHeaderName":"X-Amzn-Mtls-Clientcert-Subject","Values":["*CN=parceiro-b","CN=parceiro-b,*"]}},
    {"Field":"path-pattern","PathPatternConfig":{"Values":["/parceiro-b/*"]}}
  ]' \
  --actions "Type=forward,TargetGroupArn=${TG_ARN}"

Atenção à ordem: o ALB imprime o subject no formato RFC2253, que inverte a ordem em que os campos foram gravados. Um certificado emitido com -subj "/CN=parceiro-a/O=Parceiros/C=BR" chega como C=BR,O=Parceiros,CN=parceiro-a, com o CN no final. Por isso a regra tem dois valores (eles funcionam como OU): *CN=parceiro-a casa quando o CN é o último campo e CN=parceiro-a,* quando é o primeiro. Para conferir como o seu certificado vai aparecer:

openssl x509 -in clientes/parceiro-a.pem -noout -subject -nameopt RFC2253

Não use *CN=parceiro-a* solto: ele também casaria com um parceiro-ab que você crie no futuro.

Por que não usar só o token do GitLab? Porque o token vaza. Fica em variável de CI, em log de pipeline mal configurado, em print de tela. Com mTLS na frente, um token vazado sozinho não serve para nada fora do runner que tem o certificado.

10. Passo 7: Lado do parceiro (GitHub Actions)

O parceiro guarda três secrets no repositório: MIRROR_CERT (conteúdo do .pem), MIRROR_KEY (conteúdo do .key) e MIRROR_TOKEN (project access token do GitLab com write_repository).

.github/workflows/mirror.yml:

name: mirror-gitlab
on:
  push:
    branches: ["**"]
    tags: ["**"]

jobs:
  mirror:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Certificado de cliente
        run: |
          install -m 700 -d "$HOME/.mtls"
          printf '%s\n' "${{ secrets.MIRROR_CERT }}" > "$HOME/.mtls/cliente.pem"
          printf '%s\n' "${{ secrets.MIRROR_KEY }}"  > "$HOME/.mtls/cliente.key"
          chmod 600 "$HOME/.mtls/"*

      - name: Push mirror
        env:
          TOKEN: ${{ secrets.MIRROR_TOKEN }}
        run: |
          git config --global http.https://git-mirror.<SEU_DOMINIO>/.sslCert "$HOME/.mtls/cliente.pem"
          git config --global http.https://git-mirror.<SEU_DOMINIO>/.sslKey  "$HOME/.mtls/cliente.key"
          git push --mirror "https://oauth2:${TOKEN}@git-mirror.<SEU_DOMINIO>/parceiro-a/<REPO>.git"

      - name: Limpeza
        if: always()
        run: rm -rf "$HOME/.mtls"

O http.<url>.sslCert limita o certificado a esse host. Se usar só http.sslCert, o git manda o certificado para qualquer servidor HTTPS, incluindo o github.com no checkout.

push --mirror apaga refs. Ele remove do destino o que não existe na origem. É o comportamento certo para mirror, mas confirme que ninguém faz commit direto no repositório de destino. Se fizer, vai perder.

11. Passo 8: Logs de conexão

Os access logs normais do ALB não mostram falha de handshake, porque a requisição HTTP nunca existiu. Para mTLS, o que importa são os connection logs:

aws elbv2 modify-load-balancer-attributes --load-balancer-arn "$ALB_ARN" \
  --attributes \
    Key=connection_logs.s3.enabled,Value=true \
    Key=connection_logs.s3.bucket,Value=<BUCKET_LOGS> \
    Key=connection_logs.s3.prefix,Value=alb-git-mirror

O bucket precisa da policy padrão de logs do ELB para a região. Cada linha traz IP de origem, porta, protocolo TLS, subject e serial do certificado do cliente, e o resultado da verificação (Success ou o motivo da falha, como certificado expirado ou CA desconhecida).

12. Passo 9: Testar

# Sem certificado: deve falhar no handshake
curl -v "https://${DOMINIO}/parceiro-a/" 2>&1 | grep -iE "alert|handshake|reset|error"

# Com certificado do parceiro A no caminho dele: deve chegar no GitLab (302 ou 200)
curl -s -o /dev/null -w "%{http_code}\n" \
  --cert ~/ca-mtls/clientes/parceiro-a.pem --key ~/ca-mtls/clientes/parceiro-a.key \
  "https://${DOMINIO}/parceiro-a/"

# Parceiro A no caminho do B: deve dar 404 do listener
curl -s -o /dev/null -w "%{http_code}\n" \
  --cert ~/ca-mtls/clientes/parceiro-a.pem --key ~/ca-mtls/clientes/parceiro-a.key \
  "https://${DOMINIO}/parceiro-b/"

# git ls-remote com certificado
GIT_SSL_CERT=~/ca-mtls/clientes/parceiro-a.pem GIT_SSL_KEY=~/ca-mtls/clientes/parceiro-a.key \
  git ls-remote "https://oauth2:<TOKEN>@${DOMINIO}/parceiro-a/<REPO>.git"

Os três resultados de curl têm que ser, nessa ordem: falha de handshake, código do GitLab, 404.

13. Passo 10: Revogar um parceiro

cd ~/ca-mtls
openssl ca -config openssl.cnf -revoke clientes/parceiro-b.pem
openssl ca -config openssl.cnf -gencrl -out crl/ca.crl
openssl crl -in crl/ca.crl -noout -text | grep -A1 "Serial Number"

aws s3 cp crl/ca.crl "s3://${TS_BUCKET}/truststore/crl.pem"

aws elbv2 add-trust-store-revocations --trust-store-arn "$TS_ARN" \
  --revocation-contents "S3Bucket=${TS_BUCKET},S3Key=truststore/crl.pem,RevocationType=CRL"

aws elbv2 describe-trust-store-revocations --trust-store-arn "$TS_ARN"

Repita o curl do parceiro B: deve falhar no handshake. Os outros continuam funcionando.

A CRL gerada tem validade de default_crl_days (30 dias no exemplo). Coloque na agenda a regeração mensal, ou aumente esse valor se a CA for usada só para isso.

14. Troubleshooting

Sintoma	Causa provável	Ação
Trust store em `CREATING` e depois erro	PEM com chave privada junto ou CA sem `CA:true`	Bundle só com certificados de CA
Handshake falha mesmo com certificado	Certificado sem `clientAuth` ou emitido por outra CA	`openssl x509 -text` e conferir issuer
Target `unhealthy` com 404	`monitoring_whitelist` do GitLab	Liberar CIDR da VPC
Funciona com curl e falha no git	Git mandando certificado para outro host ou não mandando	`GIT_CURL_VERBOSE=1 GIT_TRACE=1`
Regra nunca casa e tudo dá 404	Formato do subject diferente do esperado	Conferir subject no connection log
Push dá 401	mTLS ok, token do GitLab errado ou sem escopo	Project access token com `write_repository`

15. Referências

Mutual TLS no ALB: https://docs.aws.amazon.com/elasticloadbalancing/latest/application/mutual-authentication.html
Connection logs do ALB: https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html
Health check do GitLab: https://docs.gitlab.com/ee/administration/monitoring/health_check.html
openssl ca: https://docs.openssl.org/master/man1/openssl-ca/

CDC do SQL Server para o Amazon MSK com Debezium no MSK Connect: IAM, Secrets Manager e alerta de conexão

Railander Marques — Thu, 12 Nov 2026 12:24:04 +0000

1. Objetivo

Capturar as alterações (INSERT, UPDATE, DELETE) de tabelas de um SQL Server e publicar cada evento em tópicos do Amazon MSK, usando o conector Debezium rodando no MSK Connect, com autenticação IAM no cluster, senha do banco no Secrets Manager e alerta por e-mail quando o conector perder conexão com o banco.

Resultado esperado: cada tabela vira um tópico <PREFIXO>.<DATABASE>.dbo.<TABELA>, o snapshot inicial é carregado sozinho e, a partir dali, só as mudanças trafegam. Se o banco cair ou a rede oscilar, alguém recebe um e-mail dizendo qual conector falhou e qual foi o erro.

Esse é o tipo de pipeline que parece simples no diagrama e dá trabalho na hora de subir. A maior parte das falhas que eu vejo não é no Debezium em si, é em três lugares: CDC mal habilitado no banco, autenticação IAM esquecida no tópico de histórico de schema, e security group.

2. Arquitetura

+-------------------+        1433/tcp        +----------------------+
|   SQL Server      | <--------------------- |   MSK Connect        |
|   (RDS ou EC2)    |                        |   Debezium SQL Server|
|   CDC habilitado  |                        |   (worker na VPC)    |
+-------------------+                        +----------+-----------+
                                                        |
                                          9098/tcp      | SASL_SSL + AWS_MSK_IAM
                                                        v
                                             +----------------------+
                                             |   Amazon MSK         |
                                             |   topicos por tabela |
                                             |   + schema history   |
                                             +----------------------+

       logs do worker
MSK Connect -------> CloudWatch Logs --(subscription filter)--> Lambda --> SES (e-mail)

Componentes:

Componente	Função
SQL Server com CDC	Gera as tabelas de change data no schema `cdc`
Custom plugin	Zip com o Debezium, o config provider do Secrets Manager e a lib de IAM do MSK
Worker configuration	Converters e config provider
Connector	Configuração do Debezium apontando para o banco e para o MSK
Lambda + SES	Alerta quando aparece erro de conexão no log

3. Pré-requisitos

[ ] Cluster MSK (provisionado ou serverless) com IAM access control habilitado (porta 9098)
[ ] SQL Server 2016 SP1 ou superior, edição que suporte CDC (Standard ou Enterprise)
[ ] SQL Server Agent rodando (no RDS ele já fica ativo)
[ ] Bucket S3 para o custom plugin
[ ] Subnets privadas com rota até o banco e até o MSK
[ ] Identidade verificada no SES para o remetente do alerta
[ ] AWS CLI v2 configurado com permissão para kafkaconnect, iam, secretsmanager, logs e lambda

Variáveis usadas no tutorial (ajuste e exporte antes de começar):

export AWS_REGION="us-east-1"
export ACCOUNT_ID="<ACCOUNT_ID>"
export MSK_CLUSTER_ARN="arn:aws:kafka:us-east-1:<ACCOUNT_ID>:cluster/<CLUSTER_NAME>/<CLUSTER_UUID>"
export BOOTSTRAP_IAM="b-1.<cluster>.kafka.us-east-1.amazonaws.com:9098,b-2.<cluster>.kafka.us-east-1.amazonaws.com:9098"
export PLUGIN_BUCKET="<BUCKET_PLUGINS>"
export SECRET_NAME="<SECRET_SQLSERVER>"
export CONNECTOR_NAME="prd-cdc-<sistema>"
export TOPIC_PREFIX="<PREFIXO>"
export DATABASE="<DATABASE>"
export SUBNETS="subnet-aaaa,subnet-bbbb"
export SG_CONNECT="sg-<CONNECT>"

4. Passo 1: Habilitar CDC no SQL Server

4.1 Habilitar no banco

RDS for SQL Server (não tem sysadmin, então usa a procedure da AWS):

EXEC msdb.dbo.rds_cdc_enable_db '<DATABASE>';

SQL Server em EC2 ou on-premises:

USE <DATABASE>;
EXEC sys.sp_cdc_enable_db;

Confira:

SELECT name, is_cdc_enabled FROM sys.databases WHERE name = '<DATABASE>';

4.2 Habilitar por tabela

Crie uma role de acesso (gating role) para o Debezium e habilite cada tabela:

USE <DATABASE>;
CREATE ROLE cdc_reader;

EXEC sys.sp_cdc_enable_table
    @source_schema        = N'dbo',
    @source_name          = N'pedido',
    @role_name            = N'cdc_reader',
    @supports_net_changes = 0;

EXEC sys.sp_cdc_enable_table
    @source_schema        = N'dbo',
    @source_name          = N'cliente',
    @role_name            = N'cdc_reader',
    @supports_net_changes = 0;

Valide que as capture instances existem e que os jobs foram criados:

EXEC sys.sp_cdc_help_change_data_capture;
EXEC sys.sp_cdc_help_jobs;

Atenção à retenção do CDC. O job de cleanup apaga as alterações depois de 3 dias por padrão (retention = 4320 minutos). Se o conector ficar parado mais tempo que isso, ele perde eventos e você vai precisar refazer o snapshot. Em ambiente onde o conector pode ficar fora no fim de semana, aumente:
EXEC sys.sp_cdc_change_job @job_type = N'cleanup', @retention = 10080; -- 7 dias

4.3 Usuário do Debezium

USE master;
CREATE LOGIN debezium WITH PASSWORD = '<SENHA_FORTE>';

USE <DATABASE>;
CREATE USER debezium FOR LOGIN debezium;
ALTER ROLE cdc_reader ADD MEMBER debezium;
ALTER ROLE db_datareader ADD MEMBER debezium;
GRANT VIEW DATABASE STATE TO debezium;

O db_datareader é para o snapshot inicial. Se quiser restringir mais, troque por GRANT SELECT só nas tabelas capturadas e no schema cdc.

Tabela alterada depois do CDC habilitado. Se alguém fizer ALTER TABLE ADD COLUMN, a capture instance antiga não enxerga a coluna nova. É preciso criar uma segunda capture instance para a tabela (o SQL Server permite duas) e depois desabilitar a antiga. O Debezium troca de uma para a outra sozinho. Combine isso com quem faz deploy de banco, senão a coluna simplesmente não chega no tópico e ninguém percebe.

5. Passo 2: Secret do banco

aws secretsmanager create-secret \
  --name "$SECRET_NAME" \
  --secret-string '{"username":"debezium","password":"<SENHA_FORTE>"}'

A senha nunca vai aparecer em texto claro na configuração do conector. O MSK Connect resolve ${secretsmanager:...} em tempo de execução.

6. Passo 3: Montar o custom plugin

O plugin é um zip único com tudo que o worker precisa carregar. Monte numa máquina com acesso à internet:

DBZ_VERSION="2.7.3.Final"
IAM_AUTH_VERSION="2.2.0"

mkdir -p plugin && cd plugin

# Debezium SQL Server
curl -sLO "https://repo1.maven.org/maven2/io/debezium/debezium-connector-sqlserver/${DBZ_VERSION}/debezium-connector-sqlserver-${DBZ_VERSION}-plugin.tar.gz"
tar xzf "debezium-connector-sqlserver-${DBZ_VERSION}-plugin.tar.gz"
rm -f ./*.tar.gz

# Lib de autenticacao IAM do MSK (usada pelo producer/consumer do schema history)
curl -sLO "https://github.com/aws/aws-msk-iam-auth/releases/download/v${IAM_AUTH_VERSION}/aws-msk-iam-auth-${IAM_AUTH_VERSION}-all.jar"
mv aws-msk-iam-auth-*-all.jar debezium-connector-sqlserver/

# Config provider do Secrets Manager (baixe o zip "with-dependencies" da pagina de releases)
# https://github.com/aws-samples/msk-config-providers/releases
unzip -q msk-config-providers-*-with-dependencies.zip -d debezium-connector-sqlserver/

cd .. && (cd plugin && zip -qr ../debezium-sqlserver-plugin.zip .)
aws s3 cp debezium-sqlserver-plugin.zip "s3://${PLUGIN_BUCKET}/plugins/debezium-sqlserver-plugin.zip"

Crie o plugin:

aws kafkaconnect create-custom-plugin \
  --name "debezium-sqlserver-${DBZ_VERSION//./-}" \
  --content-type ZIP \
  --location "s3Location={bucketArn=arn:aws:s3:::${PLUGIN_BUCKET},fileKey=plugins/debezium-sqlserver-plugin.zip}"

Aguarde o estado ACTIVE:

aws kafkaconnect list-custom-plugins \
  --query "customPlugins[].{nome:name,estado:customPluginState,arn:customPluginArn}" --output table

Versão do Kafka Connect. O Debezium 2.x precisa de Java 11 ou superior. Crie o conector com kafkaConnectVersion 3.7.x. Com a 2.7.1 você ganha erros de classe que não dizem nada com nada.

7. Passo 4: Role de execução do conector

Trust policy (trust-kafkaconnect.json):

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": { "Service": "kafkaconnect.amazonaws.com" },
      "Action": "sts:AssumeRole",
      "Condition": {
        "StringEquals": { "aws:SourceAccount": "<ACCOUNT_ID>" }
      }
    }
  ]
}

Permissões (policy-connector.json). Repare que tópico e grupo têm ARN próprio, com cluster/ trocado por topic/ e group/:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "Cluster",
      "Effect": "Allow",
      "Action": ["kafka-cluster:Connect", "kafka-cluster:DescribeCluster"],
      "Resource": "arn:aws:kafka:us-east-1:<ACCOUNT_ID>:cluster/<CLUSTER_NAME>/<CLUSTER_UUID>"
    },
    {
      "Sid": "Topicos",
      "Effect": "Allow",
      "Action": [
        "kafka-cluster:CreateTopic",
        "kafka-cluster:DescribeTopic",
        "kafka-cluster:WriteData",
        "kafka-cluster:ReadData"
      ],
      "Resource": "arn:aws:kafka:us-east-1:<ACCOUNT_ID>:topic/<CLUSTER_NAME>/<CLUSTER_UUID>/*"
    },
    {
      "Sid": "Grupos",
      "Effect": "Allow",
      "Action": ["kafka-cluster:AlterGroup", "kafka-cluster:DescribeGroup"],
      "Resource": "arn:aws:kafka:us-east-1:<ACCOUNT_ID>:group/<CLUSTER_NAME>/<CLUSTER_UUID>/*"
    },
    {
      "Sid": "SecretBanco",
      "Effect": "Allow",
      "Action": "secretsmanager:GetSecretValue",
      "Resource": "arn:aws:secretsmanager:us-east-1:<ACCOUNT_ID>:secret:<SECRET_SQLSERVER>-*"
    }
  ]
}

aws iam create-role --role-name msk-connect-debezium \
  --assume-role-policy-document file://trust-kafkaconnect.json

aws iam put-role-policy --role-name msk-connect-debezium \
  --policy-name debezium-msk \
  --policy-document file://policy-connector.json

Se quiser travar ainda mais, troque o /* dos tópicos por /<PREFIXO>.* e /schema-history.*.

8. Passo 5: Security groups

Origem	Destino	Porta	Motivo
`sg-CONNECT`	SG do SQL Server	1433/tcp	Debezium lendo o banco
`sg-CONNECT`	SG do MSK	9098/tcp	Producer IAM
`sg-CONNECT`	VPC endpoint Secrets Manager (ou NAT)	443/tcp	Resolver o secret

O worker do MSK Connect roda dentro das suas subnets. Se as subnets não têm NAT, crie um VPC endpoint de interface para o Secrets Manager. Sem isso o conector fica em CREATING por um bom tempo e depois falha com timeout no config provider.

aws ec2 authorize-security-group-ingress --group-id <SG_SQLSERVER> \
  --protocol tcp --port 1433 --source-group "$SG_CONNECT"

aws ec2 authorize-security-group-ingress --group-id <SG_MSK> \
  --protocol tcp --port 9098 --source-group "$SG_CONNECT"

9. Passo 6: Worker configuration

cat > worker.properties <<'EOF'
key.converter=org.apache.kafka.connect.json.JsonConverter
value.converter=org.apache.kafka.connect.json.JsonConverter
key.converter.schemas.enable=false
value.converter.schemas.enable=false
config.providers=secretsmanager
config.providers.secretsmanager.class=com.amazonaws.kafka.config.providers.SecretsManagerConfigProvider
config.providers.secretsmanager.param.region=us-east-1
EOF

aws kafkaconnect create-worker-configuration \
  --name "debezium-json-secrets" \
  --properties-file-content "$(base64 -w0 worker.properties)"

10. Passo 7: Criar o conector

Configuração do Debezium (connector.json). O bloco do schema.history.internal.* é o ponto onde 90% das primeiras tentativas quebram:

{
  "connector.class": "io.debezium.connector.sqlserver.SqlServerConnector",
  "tasks.max": "1",

  "database.hostname": "<SQLSERVER_HOST>",
  "database.port": "1433",
  "database.user": "${secretsmanager:<SECRET_SQLSERVER>:username}",
  "database.password": "${secretsmanager:<SECRET_SQLSERVER>:password}",
  "database.names": "<DATABASE>",
  "database.encrypt": "true",
  "database.trustServerCertificate": "true",

  "topic.prefix": "<PREFIXO>",
  "table.include.list": "dbo.pedido,dbo.cliente",
  "snapshot.mode": "initial",

  "topic.creation.default.replication.factor": "3",
  "topic.creation.default.partitions": "3",

  "schema.history.internal.kafka.bootstrap.servers": "<BOOTSTRAP_IAM>",
  "schema.history.internal.kafka.topic": "schema-history.<PREFIXO>",

  "schema.history.internal.producer.security.protocol": "SASL_SSL",
  "schema.history.internal.producer.sasl.mechanism": "AWS_MSK_IAM",
  "schema.history.internal.producer.sasl.jaas.config": "software.amazon.msk.auth.iam.IAMLoginModule required;",
  "schema.history.internal.producer.sasl.client.callback.handler.class": "software.amazon.msk.auth.iam.IAMClientCallbackHandler",

  "schema.history.internal.consumer.security.protocol": "SASL_SSL",
  "schema.history.internal.consumer.sasl.mechanism": "AWS_MSK_IAM",
  "schema.history.internal.consumer.sasl.jaas.config": "software.amazon.msk.auth.iam.IAMLoginModule required;",
  "schema.history.internal.consumer.sasl.client.callback.handler.class": "software.amazon.msk.auth.iam.IAMClientCallbackHandler"
}

Por que isso importa: o MSK Connect configura IAM para o producer principal do worker, mas o Debezium abre outro producer e outro consumer só para o tópico de histórico de schema. Esses dois não herdam nada. Sem o bloco acima o conector sobe, tenta falar com o broker em 9098 sem SASL e fica preso em TimeoutException na criação do tópico de histórico.

Sobre database.encrypt: o driver JDBC da Microsoft a partir da versão 10 liga criptografia por padrão. Se o SQL Server usa certificado autoassinado (o padrão em EC2 e on-prem), sem trustServerCertificate=true o erro é PKIX path building failed. Em produção, o ideal é importar a CA do banco no truststore, mas isso dá outro tutorial.

Crie o conector:

PLUGIN_ARN=$(aws kafkaconnect list-custom-plugins \
  --query "customPlugins[?starts_with(name,'debezium-sqlserver')].customPluginArn | [0]" --output text)

WORKER_ARN=$(aws kafkaconnect list-worker-configurations \
  --query "workerConfigurations[?name=='debezium-json-secrets'].workerConfigurationArn | [0]" --output text)

ROLE_ARN="arn:aws:iam::${ACCOUNT_ID}:role/msk-connect-debezium"

aws logs create-log-group --log-group-name "/msk/connect/${CONNECTOR_NAME}"
aws logs put-retention-policy --log-group-name "/msk/connect/${CONNECTOR_NAME}" --retention-in-days 14

aws kafkaconnect create-connector \
  --connector-name "$CONNECTOR_NAME" \
  --kafka-connect-version "3.7.x" \
  --service-execution-role-arn "$ROLE_ARN" \
  --plugins "customPlugin={customPluginArn=${PLUGIN_ARN},revision=1}" \
  --worker-configuration "workerConfigurationArn=${WORKER_ARN},revision=1" \
  --capacity "provisionedCapacity={mcuCount=1,workerCount=1}" \
  --kafka-cluster "apacheKafkaCluster={bootstrapServers=${BOOTSTRAP_IAM},vpc={subnets=[${SUBNETS}],securityGroups=[${SG_CONNECT}]}}" \
  --kafka-cluster-client-authentication "authenticationType=IAM" \
  --kafka-cluster-encryption-in-transit "encryptionType=TLS" \
  --log-delivery "workerLogDelivery={cloudWatchLogs={enabled=true,logGroup=/msk/connect/${CONNECTOR_NAME}}}" \
  --connector-configuration file://connector.json

Um conector Debezium SQL Server por banco com tasks.max=1 resolve a maioria dos casos. Mais de uma task só faz diferença quando database.names tem vários bancos.

Mais de um conector no mesmo log group. Funciona, mas o alerta do passo 9 precisa descobrir qual conector gerou a linha. Prefira um log group por conector. Se herdar um ambiente em que todos escrevem no mesmo, o nome do conector aparece no contexto da linha de log ([<nome-conector>|task-0]) e dá para extrair com regex.

11. Passo 8: Validar

Estado do conector:

aws kafkaconnect list-connectors \
  --query "connectors[?connectorName=='${CONNECTOR_NAME}'].{estado:connectorState,arn:connectorArn}" --output table

Acompanhe o snapshot pelo log:

aws logs tail "/msk/connect/${CONNECTOR_NAME}" --follow \
  --filter-pattern '?"Snapshot" ?"snapshot" ?ERROR'

As linhas que importam são Snapshot step 7 - Snapshotting data e depois Snapshot completed. A partir dali ele entra em streaming.

Consumir o tópico a partir de uma EC2 na mesma VPC (com o jar aws-msk-iam-auth em kafka/libs e uma role com ReadData):

cat > client.properties <<'EOF'
security.protocol=SASL_SSL
sasl.mechanism=AWS_MSK_IAM
sasl.jaas.config=software.amazon.msk.auth.iam.IAMLoginModule required;
sasl.client.callback.handler.class=software.amazon.msk.auth.iam.IAMClientCallbackHandler
EOF

./bin/kafka-topics.sh --bootstrap-server "$BOOTSTRAP_IAM" \
  --command-config client.properties --list | grep "$TOPIC_PREFIX"

./bin/kafka-console-consumer.sh --bootstrap-server "$BOOTSTRAP_IAM" \
  --consumer.config client.properties \
  --topic "${TOPIC_PREFIX}.${DATABASE}.dbo.pedido" --from-beginning --max-messages 5

Faça um UPDATE de teste no banco e confira o evento com "op":"u" e os blocos before e after.

12. Passo 9: Alerta de erro de conexão com o banco

Os erros que aparecem na prática quando o banco some ou a rede oscila:

SQLServerException: Connection timed out
SQLServerException: Connection reset
SQLServerException: The connection is closed
Login failed for user (senha trocada sem atualizar o secret)

O Debezium tenta reconectar sozinho, mas se a task morrer ela fica FAILED e o MSK Connect não reinicia. Então o alerta precisa existir.

12.1 Lambda

lambda_function.py:

import base64
import gzip
import json
import os
import re

import boto3

ses = boto3.client("ses", region_name=os.environ.get("SES_REGION", "us-east-1"))

REMETENTE = os.environ["REMETENTE"]
DESTINATARIOS = [d.strip() for d in os.environ["DESTINATARIOS"].split(",") if d.strip()]
PADROES = [
    "Connection timed out",
    "Connection reset",
    "The connection is closed",
    "Login failed for user",
]
RE_CONECTOR = re.compile(r"\[([A-Za-z0-9._-]+)\|task-\d+\]")


def descobrir_conector(mensagem, log_group, log_stream):
    achou = RE_CONECTOR.search(mensagem)
    if achou:
        return achou.group(1)
    return f"{log_group} ({log_stream})"


def lambda_handler(event, context):
    dados = json.loads(gzip.decompress(base64.b64decode(event["awslogs"]["data"])))
    if dados.get("messageType") != "DATA_MESSAGE":
        return

    falhas = {}
    for ev in dados["logEvents"]:
        msg = ev["message"]
        if not any(p in msg for p in PADROES):
            continue
        conector = descobrir_conector(msg, dados["logGroup"], dados["logStream"])
        falhas.setdefault(conector, []).append(msg.strip()[:1500])

    for conector, linhas in falhas.items():
        corpo = (
            f"O conector {conector} registrou erro de conexao com o banco.\n\n"
            f"Ocorrencias neste lote: {len(linhas)}\n\n"
            "Primeira ocorrencia:\n"
            f"{linhas[0]}\n\n"
            "Verifique o estado do conector no MSK Connect e a conectividade com o SQL Server.\n"
        )
        ses.send_email(
            Source=REMETENTE,
            Destination={"ToAddresses": DESTINATARIOS},
            Message={
                "Subject": {"Data": f"[CDC] Falha de conexao: {conector}"},
                "Body": {"Text": {"Data": corpo}},
            },
        )

Variáveis de ambiente:

Variável	Exemplo
`REMETENTE`	`alertas@<dominio-verificado>`
`DESTINATARIOS`	`time-dados@<empresa>,plantao@<empresa>`
`SES_REGION`	`us-east-1`

Destinatários mudam. Deixe a lista só na variável de ambiente e não no código, e não deixe o seu script de deploy sobrescrever as variáveis. Quem opera o ambiente costuma ajustar direto no console e não vai gostar de ver a lista voltar ao valor antigo no próximo deploy.

A role da Lambda precisa de ses:SendEmail na identidade do remetente e da policy gerenciada AWSLambdaBasicExecutionRole.

12.2 Subscription filter

LAMBDA_ARN="arn:aws:lambda:us-east-1:${ACCOUNT_ID}:function:cdc-alerta-conexao"

aws lambda add-permission \
  --function-name cdc-alerta-conexao \
  --statement-id cwlogs-${CONNECTOR_NAME} \
  --principal logs.amazonaws.com \
  --action lambda:InvokeFunction \
  --source-arn "arn:aws:logs:us-east-1:${ACCOUNT_ID}:log-group:/msk/connect/${CONNECTOR_NAME}:*"

aws logs put-subscription-filter \
  --log-group-name "/msk/connect/${CONNECTOR_NAME}" \
  --filter-name "erro-conexao-banco" \
  --filter-pattern '?"Connection timed out" ?"Connection reset" ?"The connection is closed" ?"Login failed for user"' \
  --destination-arn "$LAMBDA_ARN"

O filtro já corta o volume no CloudWatch, então a Lambda só é invocada quando tem erro. A checagem dentro do código é redundante de propósito: se alguém afrouxar o filtro depois, o e-mail continua só saindo para erro de conexão.

12.3 Testar sem derrubar o banco

Remova temporariamente a regra de 1433 do SG do banco:

aws ec2 revoke-security-group-ingress --group-id <SG_SQLSERVER> \
  --protocol tcp --port 1433 --source-group "$SG_CONNECT"

Em alguns minutos aparece o Connection timed out no log e o e-mail chega. Recoloque a regra e confirme que o conector voltou (se a task tiver ido para FAILED, será preciso recriar ou atualizar o conector para ela subir de novo).

Evite spam de alerta. Um banco fora por 30 minutos gera dezenas de linhas. Se isso incomodar, guarde o horário do último envio por conector numa tabela DynamoDB com TTL e só envie de novo depois de N minutos.

13. Troubleshooting

Sintoma	Causa provável	Ação
Conector fica em `CREATING` e falha depois de ~20 min	Worker sem saída para o Secrets Manager ou sem rota para o MSK	VPC endpoint do Secrets Manager, SG do MSK em 9098
`TimeoutException` ao criar `schema-history.*`	Producer/consumer do schema history sem SASL IAM	Bloco `schema.history.internal.*` do passo 7
`PKIX path building failed`	Driver JDBC com encrypt ligado e certificado autoassinado	`database.trustServerCertificate=true` ou CA no truststore
Snapshot termina e nenhum evento novo chega	SQL Server Agent parado ou jobs de capture desabilitados	`EXEC sys.sp_cdc_help_jobs` e status do Agent
`TopicAuthorizationException`	ARN de tópico errado na policy	Conferir `topic/<cluster>/<uuid>/*`
Coluna nova não aparece no evento	Capture instance antiga	Criar nova capture instance para a tabela
Conector parado por dias e voltou com erro de LSN	Cleanup do CDC apagou o histórico	Aumentar retenção e refazer snapshot

14. Referências

Debezium connector for SQL Server: https://debezium.io/documentation/reference/stable/connectors/sqlserver.html
MSK Connect, custom plugins: https://docs.aws.amazon.com/msk/latest/developerguide/msk-connect-plugins.html
MSK IAM access control: https://docs.aws.amazon.com/msk/latest/developerguide/iam-access-control.html
Config providers para MSK Connect: https://github.com/aws-samples/msk-config-providers
CDC no RDS for SQL Server: https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.SQLServer.CommonDBATasks.CDC.html

AWS Managed Microsoft AD - integração com FortiGate

Railander Marques — Fri, 14 Aug 2026 13:32:14 +0000

1. Objetivo

Migrar a autenticação LDAP do FortiGate do cliente (hoje em texto claro na porta 389, via túnel VPN) para LDAPS na porta 636, com criptografia TLS ponta a ponta, mantendo o mesmo diretório AWS Managed Microsoft AD.

Resultado esperado: os DCs gerenciados passam a escutar em 636 com um certificado válido, e o FortiGate valida esse certificado contra a CA que confiamos nele.

2. Conceitos — o que confunde todo mundo

2.1 Server-side vs client-side LDAPS

O console do AWS Directory Service tem uma aba de LDAPS com opção de registrar certificado. Ela não serve para este cenário.

	Client-side LDAPS	Server-side LDAPS (o nosso caso)
Quem é o servidor LDAP	Um AD self-managed / outro diretório	O AWS Managed AD
Quem é o cliente LDAP	O AWS Managed AD e apps AWS	O FortiGate
O que se faz no console	Importa o certificado da CA do outro lado e habilita	Nada
Onde está o trabalho	Console	Dentro da EC2 de gerência

Ou seja: não há nada para habilitar, importar ou emitir pelo console do Directory Service. A porta 636 sobe sozinha no momento em que os DCs recebem um certificado válido. Todo o trabalho é PKI dentro do Windows.

2.2 Por que não dá para subir um `.pfx` qualquer

O AWS Managed AD é serviço gerenciado: você não tem RDP nem administrador local nos DCs. A única forma de instalar um certificado neles é o autoenrollment do Active Directory — o próprio DC solicita o certificado a uma CA da floresta e instala sozinho.

Consequência: a CA precisa ser uma Microsoft Enterprise CA ingressada no domínio. Certificado de CA standalone, de CA pública (DigiCert, Let's Encrypt) ou arquivo avulso não funcionam — não é limitação da AWS, é como o autoenrollment do AD funciona.

2.3 A cadeia de confiança

Três certificados diferentes, papéis diferentes:

Certificado	Onde vive	Quem usa	Sai da AWS?
Chave privada da CA	EC2 de gerência	Assina os demais	Nunca
Certificado do DC	Store `LocalMachine\My` de cada DC	Apresentado no handshake TLS da 636	Não (você nem toca nele)
Certificado público da CA	Exportado em `.cer` Base64	Importado no FortiGate	Sim — é o único que se envia

O FortiGate não envia certificado nenhum para o AD. Ele só precisa confiar em quem assinou o certificado do DC.

O certificado de VPN que o cliente eventualmente tenha enviado não tem relação com isso. VPN e LDAPS são camadas independentes: a VPN entrega o pacote na VPC, o LDAPS criptografa a sessão LDAP dentro dela.

3. Arquitetura

3.1 Topologia

   REDE DO CLIENTE                    │             AWS — VPC (sua conta)
                                      │
  ┌────────────────────┐              │    ┌──────────── Subnet privada AZ-a ────────────┐
  │     FortiGate      │              │    │  ┌───────────────────────────────────────┐  │
  │                    │              │    │  │ DC1 — AWS Managed Microsoft AD        │  │
  │ Trusted CA store:  │              │    │  │ ENI 10.0.1.10  ·  Windows Server 2019 │  │
  │  └ CORP-ROOT-CA    │              │    │  │ SG: d-xxxxxxxxxx_controllers          │  │
  └─────────┬──────────┘              │    │  └───────────────────────────────────────┘  │
            │                         │    └─────────────────────────────────────────────┘
            │ TCP 636 (LDAPS)         │
            │                         │    ┌──────────── Subnet privada AZ-b ────────────┐
  ┌─────────┴──────────┐   IPsec   ┌──┴──┐ │  ┌───────────────────────────────────────┐  │
  │  Túnel VPN / DX    │◄─────────►│ VGW │ │  │ DC2 — AWS Managed Microsoft AD        │  │
  └────────────────────┘           └──┬──┘ │  │ ENI 10.0.2.10                         │  │
                                      │    │  └───────────────────────────────────────┘  │
                                      │    └─────────────────────────────────────────────┘
                                      │
                                      │    ┌──────────── Subnet privada (gerência) ──────┐
                                      │    │  ┌───────────────────────────────────────┐  │
                                      │    │  │ EC2 Windows de gerência               │  │
                                      │    │  │  · ingressada no domínio              │  │
                                      │    │  │  · RSAT / AD Tools                    │  │
                                      │    │  │  · AD CS — Enterprise Root CA  ◄── chave privada  │
                                      │    │  └───────────────────────────────────────┘  │
                                      │    └─────────────────────────────────────────────┘

3.2 Fluxo 1 — Emissão do certificado (uma vez, automático)

  EC2 gerência                          DC1 / DC2 (gerenciados)
       │                                        │
       │  1. AD CS instalado como Enterprise CA │
       │──── publica na floresta ──────────────►│
       │     (CN=Configuration → Public Key     │
       │      Services → Certification          │
       │      Authorities / NTAuthCertificates) │
       │                                        │
       │                                        │ 2. DC detecta CA + template
       │                                        │    com permissão Autoenroll
       │                                        │
       │  3. Solicitação via RPC/DCOM (MS-ICPR) │
       │◄─────── TCP 135 + portas dinâmicas ────│
       │                                        │
       │  4. CA assina e devolve o certificado  │
       │──────────────────────────────────────► │
       │                                        │
       │                                        │ 5. Instala em LocalMachine\My
       │                                        │    → serviço LDAP abre a 636

O passo 3 é o motivo de a AWS pedir liberação ampla entre o SG do diretório e o SG da CA: o enrollment usa RPC com portas dinâmicas, não uma porta fixa.

3.3 Fluxo 2 — Autenticação do FortiGate (a cada consulta)

  FortiGate                                          DC (10.0.1.10)
      │                                                    │
      │ 1. TCP SYN :636 ─────────────────────────────────► │
      │ 2. ClientHello ──────────────────────────────────► │
      │ 3. ◄──────── ServerHello + certificado do DC       │
      │                                                    │
      │ 4. Valida: assinado pela CA que confio?            │
      │            CN/SAN bate com o nome que consultei?   │
      │            está dentro da validade?                │
      │                                                    │
      │ 5. Túnel TLS estabelecido ◄──────────────────────► │
      │ 6. LDAP bind (usuário de serviço) ───────────────► │
      │ 7. Search: (sAMAccountName=usuario) ─────────────► │
      │ 8. ◄──────── DN + grupos do usuário                │

O passo 4 é onde 90% das integrações quebram — ver seção 9.

3.4 Portas

Origem → Destino	Porta	Para quê	Obrigatória
FortiGate → DCs	TCP 636	LDAPS	Sim
FortiGate → DCs	TCP 389	LDAP em claro (legado)	Só até a migração concluir
DCs → EC2 da CA	TCP 135 + dinâmicas (49152-65535)	Autoenrollment RPC	Sim
DCs → EC2 da CA	TCP 445	CDP/AIA em file share	Se usar publicação SMB
FortiGate → DCs	TCP 3269	LDAPS no Global Catalog	Só se buscar em múltiplos domínios

4. Pré-requisitos

[ ] EC2 Windows ingressada no domínio do AWS Managed AD (a instância de gerência já existente)
[ ] Credencial no grupo Admins ou AWS Delegated Enterprise Certificate Authority Administrators do diretório (a conta Admin padrão atende)
[ ] Conectividade FortiGate → VPC já funcionando (se o 389 funciona hoje, está atendido)
[ ] Usuário de serviço para bind já existente no domínio
[ ] Janela de ~1h, sendo até 30 min só de espera pela emissão

Atenção ao DN dos objetos. No AWS Managed AD você não cria objetos em CN=Users,DC=.... Tudo fica sob a sua OU delegada: OU=Users,OU=corp,DC=corp,DC=empresa,DC=com. Errar isso é a causa mais comum de bind falhando depois que o TLS já subiu.

5. Passo 1 — Security Groups (console AWS)

Duas liberações distintas, com finalidades diferentes:

a) FortiGate → DCs (o acesso final)

EC2 → Security Groups → selecione d-xxxxxxxxxx_controllers
Inbound rules → Edit → Add rule
- Type: Custom TCP
- Port: 636
- Source: o mesmo CIDR/IP privado que hoje já libera o 389

Nunca use IP público como origem. Os DCs ficam em subnets privadas e não têm IP público — o tráfego chega exclusivamente pelo túnel.

b) DCs ↔ EC2 da CA (o enrollment)

No SG da EC2 de gerência: Inbound → All traffic → Source = SG do diretório
No SG do diretório: Outbound → All traffic → Destination = SG da EC2 de gerência

Sem o item (b) o DC nunca consegue pedir o certificado e o LDAPS jamais sobe, mesmo com o AD CS instalado corretamente.

6. Passo 2 — Instalar a CA

RDP na instância de gerência com a conta Admin do diretório. PowerShell como administrador:

Install-WindowsFeature ADCS-Cert-Authority -IncludeManagementTools

Install-AdcsCertificationAuthority -CAType EnterpriseRootCA `
  -CACommonName "CORP-ROOT-CA" `
  -CryptoProviderName "RSA#Microsoft Software Key Storage Provider" `
  -KeyLength 2048 -HashAlgorithmName SHA256 `
  -ValidityPeriod Years -ValidityPeriodUnits 10 -Force

O que cada escolha significa:

EnterpriseRootCA — é o que registra a CA na floresta e habilita autoenrollment. StandaloneRootCA não funciona para este fim.
CACommonName — nome livre. Não precisa ser o domínio; o AD CS descobre o domínio sozinho porque a instância está ingressada. Escolha algo identificável, porque esse nome vai aparecer no FortiGate do cliente.
ValidityPeriod 10 anos — validade da CA raiz. Os certificados dos DCs terão 1 ano e renovam automaticamente.

Se o cliente já possui PKI corporativa, o correto é instalar como EnterpriseSubordinateCA e submeter o request à raiz dele — nesse caso o pacote enviado precisa conter a cadeia completa, não só um certificado.

7. Passo 3 — Template de certificado

Uma Enterprise CA nova já publica por padrão os templates Domain Controller Authentication e Kerberos Authentication, e os DCs têm permissão de Autoenroll neles. Na maioria dos casos a 636 sobe sem nenhuma configuração adicional — pule para o Passo 4 e só volte aqui se não subir.

Caminho oficial da AWS, caso necessário:

Server Manager → Tools → Certification Authority
Botão direito em Certificate Templates → Manage
Botão direito em Kerberos Authentication → Duplicate Template
Aba Compatibility: Certification recipient → Windows 10 / Windows Server 2016 (os DCs do AWS Managed AD rodam Windows Server 2019)
Aba General: Template display name → LDAPOverSSL
Aba Security: selecione Domain Controllers e confirme Read, Enroll e Autoenroll marcados
OK, feche o console de templates
Botão direito em Certificate Templates → New → Certificate Template to Issue → selecione LDAPOverSSL

O template Kerberos Authentication é o escolhido porque já traz os EKUs certos (Server Authentication, Client Authentication, Smart Card Logon, KDC Authentication) e preenche o SAN com o FQDN do DC e o FQDN do domínio — é isso que permite ao FortiGate consultar por corp.empresa.com sem erro de identidade.

8. Passo 4 — Validar

Aguarde até 30 minutos após o Passo 2/3 e rode na instância de gerência:

$fqdn = (Get-WmiObject Win32_ComputerSystem).Domain
Test-NetConnection $fqdn -Port 636
certutil -dcinfo verify

Critérios de aceite:

TcpTestSucceeded : True
certutil -dcinfo verify lista os DCs com certificado válido e sem erro de cadeia

Teste funcional de bind com o ldp.exe (vem com as AD Tools):

ldp.exe → Connection → Connect
Server: FQDN do domínio · Port: 636 · marcar SSL
A janela deve retornar os atributos do RootDSE (se aparecer só erro 81 = servidor indisponível, o certificado ainda não foi emitido)
Connection → Bind com o usuário de serviço, para confirmar que a conta de bind funciona

Só avance quando os dois passarem. Se falhar aqui, o problema é seu — não adianta enviar nada ao cliente.

9. Passo 5 — Exportar o material e montar o pacote

certutil -ca.cert C:\ca-der.cer
certutil -encode C:\ca-der.cer C:\ca-publica-base64.cer
certutil -backupkey C:\backup-ca

ca-publica-base64.cer → é o arquivo que vai para o cliente. Base64/PEM é o formato que o FortiGate importa.
C:\backup-ca → backup da chave privada. Guarde em local seguro fora da instância (S3 com KMS, cofre de senhas). Nunca envie ao cliente.

Pacote a entregar:

Item	Valor
Certificado da CA	`ca-publica-base64.cer`
Servidor LDAP	FQDN do domínio, ex. `corp.empresa.com` (não IP)
IPs dos DCs	10.0.1.10 e 10.0.2.10 — apenas para DNS/rota, não para configurar como servidor
Porta	636
Base DN	`DC=corp,DC=empresa,DC=com`
Common Name Identifier	`sAMAccountName`
Usuário de bind	o mesmo já em uso no 389

10. Passo 6 — Lado do cliente (FortiGate)

GUI

System → Certificates → Import → CA Certificate → upload do .cer
User & Authentication → LDAP Servers → editar o objeto existente
Server Port → 636 · Secure Connection → marcar · Protocol → LDAPS · Certificate → a CA importada
Test Connectivity e Test User Credentials

CLI equivalente

config user ldap
    edit "AWS-Managed-AD"
        set server "corp.empresa.com"
        set cnid "sAMAccountName"
        set dn "DC=corp,DC=empresa,DC=com"
        set type regular
        set username "CN=svc_fortigate,OU=Users,OU=corp,DC=corp,DC=empresa,DC=com"
        set password ********
        set port 636
        set secure ldaps
        set ca-cert "CORP-ROOT-CA"
        set server-identity-check enable
    next
end

Validação no FortiGate:

diagnose test authserver ldap AWS-Managed-AD <usuario> <senha>

Pré-requisito no lado dele: o FortiGate precisa resolver o FQDN do domínio pelos DCs do AD. Se o DNS dele não aponta para os DCs, configure set dns-primary para o IP de um DC ou negocie o uso do FQDN do DC específico.

11. Troubleshooting

Sintoma	Causa provável	Ação
`Test-NetConnection :636` = False na instância de gerência	Certificado ainda não emitido	Aguardar 30 min; conferir SG DCs ↔ CA; conferir se a CA é Enterprise, não Standalone
Idem, após 1h	Template sem Autoenroll para Domain Controllers ou não publicado	Executar o Passo 3
`ldp.exe` erro 81	LDAP não está escutando na 636	Mesmo diagnóstico acima
636 OK interno, FortiGate não conecta	SG inbound 636 ou rota do túnel	Conferir origem da regra (IP privado, não público)
`Failed to establish SSL connection` no FortiGate	CA não importada, ou cadeia incompleta (caso subordinada)	Reenviar cadeia completa
Erro de certificado apesar da CA importada	FortiGate apontando para IP; `server-identity-check` compara com o CN/SAN	Usar FQDN, ou `set server-identity-check disable`
TLS OK mas bind falha	DN do usuário de serviço errado	Usar a OU delegada, não `CN=Users`
Funcionou e parou de funcionar ~1 ano depois	Certificado do DC expirou sem renovar	Ver seção 12

Comando de diagnóstico no FortiGate:

diagnose debug application fnbamd -1
diagnose debug enable

12. Operação contínua — o que não pode ser esquecido

Ao instalar a CA na instância de gerência, ela vira um trust anchor de longo prazo. Isso cria obrigações:

Item	Risco	Mitigação
Certificado do DC expira em 1 ano	Renovação automática só ocorre se a CA estiver online	Manter a instância viva e monitorada
Instância descartada / recriada	Perda da chave privada da CA → sem renovação e sem CRL	`certutil -backupkey` guardado fora da instância; documentar restore
CRL expira (padrão: 1 semana)	Validações de certificado passam a falhar	Aumentar o intervalo de publicação ou garantir que a CA fica online
Instância desligada por economia	Enrollment e CRL param	Não incluir essa instância em schedulers de stop

Comandos úteis de operação:

certutil -CRL                                   # publica CRL manualmente
certutil -getreg CA\CRLPeriod*                  # consulta período da CRL
certutil -getreg CA\ValidityPeriod*             # validade dos certs emitidos

Adicione ao monitoramento: expiração do certificado dos DCs, expiração da CRL e status do serviço CertSvc.

13. Anexo — por que não usar o AWS Private CA

O AWS Private CA Connector for AD faz o mesmo trabalho de forma gerenciada, sem EC2 e sem chave privada sob sua custódia. É tecnicamente superior, mas custa USD 400/mês por CA em modo general-purpose (o connector em si é gratuito; paga-se a CA e os certificados).

Para um caso de uso restrito a habilitar LDAPS, o AD CS na instância de gerência já existente resolve com custo marginal zero. O Private CA passa a valer a pena quando há emissão de certificados em escala (usuários, máquinas, mTLS) ou quando a custódia da chave privada em EC2 é inaceitável por compliance.

Diferenças operacionais relevantes:

	AD CS na EC2	AWS Private CA + Connector
Custo	Só a EC2	~USD 400/mês por CA
Chave privada	Sob sua responsabilidade	Gerenciada pela AWS
Habilitar cert nos DCs	Automático via autoenrollment	Explícito: Actions → Enable domain controller certificates
Patching / disponibilidade	Sua responsabilidade	AWS
Tempo até emissão	Até 30 min	Até 8 horas

Referências

Automação de Backups para SFTP Externo

Railander Marques — Wed, 07 Jan 2026 20:26:59 +0000

Visão Geral

Este tutorial documenta uma solução completa e robusta para a transferência automática de backups do Amazon S3 (arquivos dump do PostgreSQL, entre 5 GB e 10 GB) para servidores SFTP externos utilizando uma infraestrutura serverless da AWS em conjunto com uma instância EC2 como ponte de processamento.

Arquitetura da Solução

O sistema implementa um fluxo de trabalho event-driven que:

Detecta automaticamente novos backups depositados no S3
Valida e filtra arquivos baseado em critérios específicos (prefixo, sufixo, nome)
Aciona uma função Lambda que dispara comandos remotos via AWS Systems Manager
Processa o download seguro do S3 para uma instância EC2 (EC2 evita o timeout de execução da Lambda)
Transfere os arquivos para o servidor SFTP com verificação de integridade (EC2 para evitar o timeout)
Garante confiabilidade através de retry automático, validação MD5 e logs detalhados

Características Principais

✅ Upload resiliente: Retry automático com backoff configurável
✅ Integridade garantida: Verificação MD5 e validação de tamanho
✅ Upload multipart: Transferência otimizada para arquivos grandes (chunks de 64KB)
✅ Temporary naming: Upload com extensão .part antes da finalização
✅ Logs completos: Rastreamento detalhado em /var/log/sftp_uploader/
✅ Configuração flexível: Variáveis de ambiente via .env
✅ Autenticação múltipla: Suporte para senha ou chave SSH (RSA/OpenSSH)

Fluxo de Operação

S3 Event (PUT) → Lambda (filtro) → SSM Run Command → EC2 (download S3) 
→ Validação Local → Upload SFTP (com retry) → Verificação MD5 → Conclusão

1. Criação da Lambda

No console AWS Lambda: Create function → Author from scratch
- Name: BackupTransferLambda
- Runtime: Python 3.13
- Role: Crie uma role com permissões SSM SendCommand e S3 read.
Configure environment variables se necessário.
Faça upload do código da Lambda (arquivo lambda_function.py fornecido).

2. Configuração da Trigger do S3

No bucket S3 company-backups-bucket → Properties → Event notifications → Create Event Notification
Configurações:
- Name: TriggerBackupUpload
- Event type: PUT
- Prefix: db/daily/
- Suffix: .dump
- Destination: Lambda function → BackupTransferLambda
Salve.

3. Permissões Necessárias

EC2 Role (Alterar o nome do bucket)

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject","s3:ListBucket"],
      "Resource": [
        "arn:aws:s3:::company-backups-bucket",
        "arn:aws:s3:::company-backups-bucket/*"
      ]
    },
    {
      "Effect": "Allow",
      "Action": ["ssm:SendCommand","ssm:GetCommandInvocation"],
      "Resource": "*"
    }
  ]
}

Lambda Role (Alterar id da conta AWS, região e instancia)

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "ssm:SendCommand",
        "ssm:GetCommandInvocation"
      ],
      "Resource": [
        "arn:aws:ec2:us-east-1:123456789012:instance/i-XXXXXXXXXX",
        "arn:aws:ssm:us-east-1::document/AWS-RunShellScript"
      ]
    }
  ]
}

4. Preparação da EC2 Ubuntu 24.04 e Testes

sudo apt update && sudo apt upgrade -y
sudo apt install -y python3 python3-pip python3-venv unzip curl
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
aws --version

cd /opt
sudo mkdir sftp_uploader_app
sudo chown ubuntu:ubuntu sftp_uploader_app
cd sftp_uploader_app
python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip
pip install paramiko python-dotenv boto3
python3 -c "import paramiko; import boto3; import dotenv; print('Módulos OK')"

5. Estrutura de Pastas

/opt/sftp_uploader_app/
├── sftp_uploader.py
├── sftp_uploader_main.py
├── logrotate_sftp_uploader
├── sftp-uploader.service
├── sftp-uploader.timer
├── id_rsa
├── .env
└── venv/

/var/tmp/sftp_uploader → temporário
/var/log/sftp_uploader → logs

sudo mkdir -p /var/tmp/sftp_uploader
sudo mkdir -p /var/log/sftp_uploader
sudo chown -R ubuntu:ubuntu /var/tmp/sftp_uploader /var/log/sftp_uploader

6. Configuração do Arquivo .env

Crie o arquivo /opt/sftp_uploader_app/.env com o seguinte conteúdo:

# Configuração SFTP
SFTP_HOST=sftp.external-server.com
SFTP_PORT=22
SFTP_USER=transfer_user
SFTP_PASSWORD=your_secure_password_here
SFTP_KEY_PATH=/opt/sftp_uploader_app/id_rsa
SFTP_KEY_PASSPHRASE=your_key_passphrase

# Pasta local (temporária para download S3)
LOCAL_DIR=/var/tmp/sftp_uploader

# Pasta remota SFTP
REMOTE_DIR=/

# Apagar arquivos locais após envio
DELETE_AFTER_UPLOAD=True

# Número de tentativas em caso de falha
RETRY_ATTEMPTS=3
RETRY_DELAY_SECONDS=10

# Logs
LOG_DIR=/var/log/sftp_uploader

# MD5 para verificação de integridade
VERIFY_MD5=True

# Bucket S3
S3_BUCKET_NAME=company-backups-bucket

7. Como descompactar o zip atualizado

cd /opt
sudo unzip sftp_uploader_app.zip -d /opt/sftp_uploader_app
sudo chown -R ubuntu:ubuntu /opt/sftp_uploader_app

Conteúdo do ZIP:

env (renomear para .env)
id_rsa (chave SSH privada)
lambda_handler.py
logrotate_sftp_uploader
sftp_uploader_main.py
sftp_uploader.py
sftp-uploader.service
sftp-uploader.timer

8. Teste manual e logs

source /opt/sftp_uploader_app/venv/bin/activate
python3 /opt/sftp_uploader_app/sftp_uploader_main.py

Logs em /var/log/sftp_uploader/sftp_uploader.log
Run Command history na Lambda console

Exemplo de log:

2026-01-07 09:00:01 [INFO] Conectado ao SFTP sftp.external-server.com:22
2026-01-07 09:00:02 [INFO] Processando arquivo: /var/tmp/sftp_uploader/backup.dump -> /
2026-01-07 09:00:05 [INFO] Upload concluído (temp): backup.dump -> /backup.dump.part
2026-01-07 09:00:06 [INFO] Arquivo movido para destino: /backup.dump
2026-01-07 09:00:06 [INFO] Processamento concluído

Log Completo:

2026-01-07 10:54:12,561 [INFO] Baixando s3://company-backups-bucket/db/daily/database_client_backup.dump para /var/tmp/sftp_uploader/database_client_backup.dump
2026-01-07 10:54:12,581 [INFO] Found credentials from IAM Role: ssm
2026-01-07 10:54:36,407 [INFO] Connected (version 2.0, client AWS_SFTP_1.2)
2026-01-07 10:54:36,519 [INFO] Auth banner: b'Welcome to External SFTP Server!\n'
2026-01-07 10:54:36,520 [INFO] Authentication (publickey) successful!
2026-01-07 10:54:36,690 [INFO] [chan 0] Opened sftp connection (server version 3)
2026-01-07 10:54:36,690 [INFO] Conectado ao SFTP sftp.external-server.com:22 (attempt 1)
2026-01-07 10:54:36,691 [INFO] Processando arquivo: /var/tmp/sftp_uploader/database_client_backup.dump -> /
2026-01-07 10:54:42,737 [INFO] database_client_backup.dump - 50.0 MB enviados (1.69%)
2026-01-07 10:54:47,352 [INFO] database_client_backup.dump - 100.0 MB enviados (3.39%)
2026-01-07 10:54:52,081 [INFO] database_client_backup.dump - 150.0 MB enviados (5.08%)
[...]
2026-01-07 10:59:36,365 [INFO] Upload concluído (temp): /var/tmp/sftp_uploader/database_client_backup.dump -> /database_client_backup.dump.part
2026-01-07 11:26:07,525 [INFO] Arquivo movido para destino: /database_client_backup.dump
2026-01-07 11:26:07,676 [INFO] Arquivo local removido após upload: /var/tmp/sftp_uploader/database_client_backup.dump
2026-01-07 11:26:07,676 [INFO] Processamento concluído
2026-01-07 11:26:07,676 [INFO] [chan 0] sftp session closed.

9. Troubleshooting

Chave PPK não funciona: Paramiko precisa de chave OpenSSH (.pem ou sem conversão). Converta: puttygen chave.ppk -O private-openssh -o id_rsa
Permissões: chmod 600 id_rsa
Upload falha: Verifique prefix/suffix S3 e paths locais/remotos
SSM não executa: Confirme role da Lambda e permissões da EC2
Timeout: Ajuste TimeoutSeconds na Lambda ou banner_timeout no Paramiko
MD5 não bate: Verifique se o arquivo foi completamente transferido ou se houve corrupção

Detalhes Técnicos da Implementação

Processo de Upload Seguro

Download do S3: Arquivo baixado para /var/tmp/sftp_uploader/
Filtro: Apenas arquivos contendo palavra-chave no nome são processados (configurável)
Upload temporário: Arquivo enviado com extensão .part
Validações:
- Comparação de tamanho (bytes locais vs remotos)
- Checksum MD5 (local vs remoto)
Rename atômico: .part → nome final
Cleanup opcional: Remoção do arquivo local se DELETE_AFTER_UPLOAD=True

Mecanismo de Retry

Tentativas configuráveis via RETRY_ATTEMPTS (padrão: 3)
Delay entre tentativas: RETRY_DELAY_SECONDS (padrão: 10s)
Retry aplicado em:
- Conexão SFTP
- Upload de arquivo
- Validação MD5

Logs e Monitoramento

Logs da Lambda: CloudWatch Logs
Logs SSM: Run Command history no console AWS Systems Manager
Logs EC2: /var/log/sftp_uploader/sftp_uploader.log
Formato de log: timestamp [LEVEL] mensagem

Opção 2: Lambda com Conexão Direta SSH à EC2

Esta opção remove o SSM Run Command e estabelece uma conexão SSH direta da Lambda para a EC2 através de uma interface de rede na mesma VPC.

1. Configurar SSH no EC2

Criar arquivo de configuração para liberar login por senha apenas para o usuário sftp_user:

sudo tee /etc/ssh/sshd_config.d/10-password-auth.conf > /dev/null <<'EOF'
PasswordAuthentication no
ChallengeResponseAuthentication no
UsePAM yes

Match User sftp_user
    PasswordAuthentication yes
    AuthenticationMethods password
EOF

Reiniciar o serviço SSH:

sudo systemctl restart ssh

Validar se as diretivas foram aplicadas:

sudo sshd -T | grep -E 'password|challenge|usepam'

2. Criar usuário `sftp_user`

#!/bin/bash
#############################################
# Script de Criação de Usuário Administrativo
#############################################

set -e

if [ "$EUID" -ne 0 ]; then
    echo "❌ Este script precisa ser executado como root (sudo)"
    exit 1
fi

echo "📝 Criando novo usuário administrativo..."
read -p "Nome do usuário: " username

if [ -z "$username" ]; then
    echo "❌ Nome de usuário não pode ser vazio!"
    exit 1
fi

if id "$username" &>/dev/null; then
    echo "⚠️ Usuário já existe."
    USER_EXISTS=true
else
    USER_EXISTS=false
fi

echo ""
echo "🔐 Configuração de senha"
while true; do
    read -sp "Senha: " password
    echo ""
    read -sp "Confirme: " confirm
    echo ""
    [ "$password" = "$confirm" ] && break
    echo "Senhas não coincidem!"
done

if [ "$USER_EXISTS" = false ]; then
    useradd -m -s /bin/bash "$username"
fi

echo "$username:$password" | chpasswd

for grp in sudo wheel adm systemd-journal; do
    if getent group "$grp" >/dev/null; then
        usermod -aG "$grp" "$username"
    fi
done

SUDOERS_FILE="/etc/sudoers.d/$username"
cat > "$SUDOERS_FILE" <<INNER_EOF
$username ALL=(ALL:ALL) NOPASSWD: ALL
INNER_EOF

chmod 0440 "$SUDOERS_FILE"
visudo -c -f "$SUDOERS_FILE" >/dev/null && echo "✓ Sudo configurado"

echo "✅ Usuário $username criado com sucesso!"

Execute o script /tmp/create_user.sh para gerar o usuário.

3. Configuração de rede e segurança

Adicione política à Lambda para conseguir gerar uma interface de rede:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ec2:CreateNetworkInterface",
                "ec2:DescribeNetworkInterfaces",
                "ec2:DeleteNetworkInterface"
            ],
            "Resource": "*"
        }
    ]
}

Criar interface de rede (ENI) da Lambda na mesma VPC da EC2.
No Security Group da EC2, liberar porta 22 somente para o SG da Lambda.

4. Preparar Lambda

Alterar no handler os dados de conexão:

EC2_HOST = "<IP_PRIVADO_DA_EC2>"
EC2_USER = "sftp_user"
EC2_PASSWORD = "<SENHA_DO_USUARIO>"

Deploy da Lambda usando o arquivo ZIP com as bibliotecas necessárias (paramiko, etc)

Resumo

SSH do EC2 permite login por senha apenas para sftp_user.
Lambda conecta usando usuário e senha definidos no handler.
Porta 22 liberada apenas para a Lambda na VPC.

Arquivos de Código

lambda_function.py (Opção 1: SSM)

import boto3
import logging

# Configura logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)

# Configurações
EC2_INSTANCE_ID = "i-XXXXXXXXXX"
S3_BUCKET = "company-backups-bucket"
S3_PREFIX = "db/daily/"

# Cliente SSM
ssm = boto3.client('ssm')

def lambda_handler(event, context):
    try:
        # Obter arquivo do evento S3
        record = event['Records'][0]
        bucket = record['s3']['bucket']['name']
        key = record['s3']['object']['key']

        logger.info(f"Evento recebido do S3: bucket={bucket}, key={key}")

        # Verifica se é do bucket e prefixo correto
        if bucket != S3_BUCKET or not key.startswith(S3_PREFIX):
            logger.info(f"Ignorando arquivo fora do prefixo/bucket: {key}")
            return {"status": "ignored", "key": key}

        # Verifica se contém palavra-chave
        if 'client_backup' not in key:
            logger.info(f"Ignorando arquivo (não contém 'client_backup'): {key}")
            return {"status": "ignored", "key": key}

        # Verifica EC2 definido
        if not EC2_INSTANCE_ID:
            logger.error("EC2_INSTANCE_ID não definido!")
            return {"status": "error", "message": "EC2_INSTANCE_ID não definido"}

        # Comando a ser executado na EC2
        command = f"/opt/sftp_uploader_app/venv/bin/python3 /opt/sftp_uploader_app/sftp_uploader.py --s3-file s3://{bucket}/{key}"
        logger.info(f"Enviando comando SSM para EC2 {EC2_INSTANCE_ID}: {command}")

        # Envia comando SSM
        response = ssm.send_command(
            Targets=[{'Key': 'InstanceIds', 'Values': [EC2_INSTANCE_ID]}],
            DocumentName="AWS-RunShellScript",
            Parameters={'commands': [command]},
            TimeoutSeconds=900  # 15 minutos
        )

        command_id = response['Command']['CommandId']
        logger.info(f"Comando enviado com sucesso! CommandId: {command_id}")
        return {"status": "command_sent", "command_id": command_id, "key": key}

    except Exception as e:
        logger.exception(f"Erro ao processar evento S3: {e}")
        return {"status": "error", "message": str(e)}

lambda_function.py (Opção 2: SSH Direto)

import json
import paramiko
import time

# ============================
# CONFIGURAÇÕES FIXAS
# ============================
EC2_HOST = "10.0.1.100"  # IP privado da EC2
EC2_USER = "sftp_user"
EC2_PASSWORD = "your_secure_password"

# Caminhos no servidor EC2
PYTHON_PATH = "/opt/sftp_uploader_app/venv/bin/python3"
SCRIPT_PATH = "/opt/sftp_uploader_app/sftp_uploader.py"
LOG_PATH = "/var/log/sftp_trigger.log"
SFTP_LOG_DIR = "/var/log/sftp_uploader"
SFTP_LOG_FILE = "/var/log/sftp_uploader/sftp_uploader.log"
TEMP_DIR = "/var/tmp/sftp_uploader"

def should_process_file(filename):
    """
    Verifica se o arquivo deve ser processado.
    """
    filename_lower = filename.lower()

    if not filename_lower.endswith('.dump'):
        return False, "Arquivo não termina com .dump"

    if 'client_backup' not in filename_lower:
        return False, "Arquivo não contém 'client_backup' no nome"

    return True, "OK"

def lambda_handler(event, context):
    ssh = None
    try:
        # Extrai informações do evento S3
        record = event['Records'][0]
        bucket = record['s3']['bucket']['name']
        key = record['s3']['object']['key']
        s3_file = f"s3://{bucket}/{key}"

        filename = key.split('/')[-1]

        print(f"[INFO] Arquivo detectado: {s3_file}")
        print(f"[INFO] Nome do arquivo: {filename}")

        # Validação
        should_process, reason = should_process_file(filename)

        if not should_process:
            message = f"Arquivo ignorado: {reason}"
            print(f"[INFO] {message}")
            return {
                "statusCode": 200,
                "body": json.dumps({
                    "message": message,
                    "s3_file": s3_file,
                    "filename": filename,
                    "processed": False
                })
            }

        print(f"[INFO] Conectando na EC2 {EC2_HOST}...")

        # Conexão SSH
        ssh = paramiko.SSHClient()
        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        ssh.connect(
            hostname=EC2_HOST,
            username=EC2_USER,
            password=EC2_PASSWORD,
            timeout=20,
        )

        print("[INFO] Conexão SSH estabelecida com sucesso")

        # Preparar diretórios
        setup_commands = f"""
mkdir -p {SFTP_LOG_DIR}
chmod 777 {SFTP_LOG_DIR}
touch {SFTP_LOG_FILE}
chmod 666 {SFTP_LOG_FILE}
mkdir -p {TEMP_DIR}
chmod 777 {TEMP_DIR}
"""

        print("[INFO] Configurando diretórios...")
        stdin, stdout, stderr = ssh.exec_command(setup_commands)
        stdout.channel.recv_exit_status()

        # Monta comando
        command = (
            f"nohup {PYTHON_PATH} {SCRIPT_PATH} "
            f"--s3-file '{s3_file}' >> {LOG_PATH} 2>&1 & "
            f"echo $!"
        )

        print(f"[INFO] Executando comando: {command}")

        # Executa comando e captura PID
        stdin, stdout, stderr = ssh.exec_command(command)
        pid = stdout.read().decode().strip()

        if pid and pid.isdigit():
            print(f"[INFO] Processo iniciado com PID: {pid}")
            status_message = f"Processo iniciado com sucesso (PID: {pid})"
        else:
            print(f"[ERROR] Falha ao obter PID")
            status_message = "Falha ao iniciar processo"

        ssh.close()

        return {
            "statusCode": 200,
            "body": json.dumps({
                "message": status_message,
                "s3_file": s3_file,
                "filename": filename,
                "pid": pid if pid and pid.isdigit() else None,
                "processed": True
            })
        }

    except Exception as e:
        error_msg = f"Erro: {str(e)}"
        print(f"[ERROR] {error_msg}")
        import traceback
        print(f"[ERROR] Traceback:\n{traceback.format_exc()}")
        return {
            "statusCode": 500,
            "body": json.dumps({"error": error_msg})
        }

    finally:
        if ssh:
            try:
                ssh.close()
            except:
                pass

sftp_uploader.py

#!/usr/bin/env python3
"""
sftp_uploader.py - Upload de arquivos grandes para SFTP com download do S3
"""
import os
import sys
import time
import hashlib
import logging
from pathlib import Path
from dotenv import load_dotenv
import paramiko
import argparse
import boto3

# Carrega .env
ENV_PATH = Path(__file__).parent / '.env'
if not ENV_PATH.exists():
    ENV_PATH = Path('/opt/sftp_uploader_app/.env')
load_dotenv(dotenv_path=str(ENV_PATH))

# Configurações
SFTP_HOST = os.getenv('SFTP_HOST')
SFTP_PORT = int(os.getenv('SFTP_PORT', '22'))
SFTP_USER = os.getenv('SFTP_USER')
SFTP_PASSWORD = os.getenv('SFTP_PASSWORD') or None
SFTP_KEY_PATH = os.getenv('SFTP_KEY_PATH') or None
SFTP_KEY_PASSPHRASE = os.getenv('SFTP_KEY_PASSPHRASE') or None
LOCAL_DIR = Path(os.getenv('LOCAL_DIR', '/var/tmp/sftp_uploader'))
REMOTE_DIR = os.getenv('REMOTE_DIR', '/')
DELETE_AFTER_UPLOAD = os.getenv('DELETE_AFTER_UPLOAD', 'False').lower() in ('1','true','yes')
RETRY_ATTEMPTS = int(os.getenv('RETRY_ATTEMPTS', '3'))
RETRY_DELAY_SECONDS = int(os.getenv('RETRY_DELAY_SECONDS', '10'))
LOG_DIR = Path(os.getenv('LOG_DIR', '/var/log/sftp_uploader'))
TMP_DIR = Path(os.getenv('TMP_DIR', '/var/tmp/sftp_uploader'))
VERIFY_MD5 = os.getenv('VERIFY_MD5', 'True').lower() in ('1','true','yes')

LOG_DIR.mkdir(parents=True, exist_ok=True)
TMP_DIR.mkdir(parents=True, exist_ok=True)
LOCAL_DIR.mkdir(parents=True, exist_ok=True)

# Logging
LOG_FILE = LOG_DIR / 'sftp_uploader.log'
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.FileHandler(LOG_FILE),
        logging.StreamHandler(sys.stdout)
    ]
)
logger = logging.getLogger('sftp_uploader')

# Helpers
def md5_of_file(path: Path):
    h = hashlib.md5()
    with open(path, 'rb') as f:
        for chunk in iter(lambda: f.read(65536), b''):
            h.update(chunk)
    return h.hexdigest()

def md5_of_remote(sftp, remote_path):
    h = hashlib.md5()
    try:
        with sftp.open(remote_path, 'rb') as rf:
            for chunk in iter(lambda: rf.read(65536), b''):
                h.update(chunk)
        return h.hexdigest()
    except Exception as e:
        logger.warning(f'Falha ao calcular MD5 remoto {remote_path}: {e}')
        return None

def connect_sftp():
    last_exc = None
    for attempt in range(1, RETRY_ATTEMPTS + 1):
        try:
            transport = paramiko.Transport((SFTP_HOST, SFTP_PORT))
            transport.banner_timeout = 600
            transport.connect_timeout = 600
            if SFTP_KEY_PATH and Path(SFTP_KEY_PATH).exists():
                key = paramiko.RSAKey.from_private_key_file(SFTP_KEY_PATH, password=SFTP_KEY_PASSPHRASE)
                transport.connect(username=SFTP_USER, pkey=key)
            else:
                transport.connect(username=SFTP_USER, password=SFTP_PASSWORD)
            sftp = paramiko.SFTPClient.from_transport(transport)
            sftp.get_channel().settimeout(600)
            logger.info(f'Conectado ao SFTP {SFTP_HOST}:{SFTP_PORT} (attempt {attempt})')
            return transport, sftp
        except Exception as e:
            last_exc = e
            logger.warning(f'Falha conexão SFTP (attempt {attempt}): {e}')
            time.sleep(RETRY_DELAY_SECONDS)
    raise last_exc

def ensure_remote_dir(sftp, remote_path):
    parts = Path(remote_path).parts
    cur = ''
    for p in parts:
        if p == '/':
            continue
        cur = cur + '/' + p
        try:
            sftp.stat(cur)
        except IOError:
            try:
                sftp.mkdir(cur)
                logger.info(f'Criado dir remoto: {cur}')
            except Exception as e:
                logger.warning(f'Não foi possível criar {cur}: {e}')

def upload_file(sftp, local_path: Path, remote_dir: str):
    remote_name = local_path.name
    remote_tmp = remote_dir.rstrip('/') + '/' + remote_name + '.part'
    remote_final = remote_dir.rstrip('/') + '/' + remote_name
    last_exc = None
    for attempt in range(1, RETRY_ATTEMPTS + 1):
        try:
            filesize = local_path.stat().st_size
            with open(local_path, 'rb') as f:
                with sftp.open(remote_tmp, 'wb') as rf:
                    transferred = 0
                    while True:
                        data = f.read(65536)
                        if not data:
                            break
                        rf.write(data)
                        transferred += len(data)
                        if transferred % (50*1024*1024) < 65536:
                            logger.info(f"{local_path.name} - {transferred/1024/1024:.1f} MB enviados ({transferred/filesize*100:.2f}%)")
            logger.info(f'Upload concluído (temp): {local_path} -> {remote_tmp}')
            r_size = sftp.stat(remote_tmp).st_size
            if r_size != filesize:
                raise IOError(f'Tamanho diferente após upload (local={filesize}, remoto={r_size})')
            if VERIFY_MD5:
                local_md5 = md5_of_file(local_path)
                remote_md5 = md5_of_remote(sftp, remote_tmp)
                if remote_md5 != local_md5:
                    raise IOError(f'MD5 inválido (local={local_md5}, remoto={remote_md5})')
            try:
                sftp.rename(remote_tmp, remote_final)
            except Exception:
                try: sftp.remove(remote_final)
                except Exception: pass
                sftp.rename(remote_tmp, remote_final)
            logger.info(f'Arquivo movido para destino: {remote_final}')
            return True
        except Exception as e:
            last_exc = e
            logger.warning(f'Falha upload (attempt {attempt}): {e}')
            try: sftp.remove(remote_tmp)
            except Exception: pass
            time.sleep(RETRY_DELAY_SECONDS)
    logger.error(f'Upload definitivamente falhou: {local_path} - {last_exc}')
    return False

# Argumentos CLI
parser = argparse.ArgumentParser()
parser.add_argument("--s3-file", help="Arquivo S3 no formato s3://bucket/key")
args = parser.parse_args()

# Se fornecido --s3-file, baixa o arquivo
if args.s3_file:
    if not args.s3_file.startswith("s3://"):
        logger.error(f"Formato S3 inválido: {args.s3_file}")
        sys.exit(1)
    bucket, key = args.s3_file[5:].split("/", 1)
    local_path = LOCAL_DIR / Path(key).name
    logger.info(f"Baixando {args.s3_file} para {local_path}")
    s3 = boto3.client("s3")
    s3.download_file(bucket, key, str(local_path))

# Processamento
def process_once():
    transport = None
    sftp = None
    try:
        transport, sftp = connect_sftp()
        ensure_remote_dir(sftp, REMOTE_DIR)
        for root, dirs, files in os.walk(LOCAL_DIR):
            for fname in files:
                if "client_backup" not in fname:
                    logger.info(f"Arquivo ignorado (não contém 'client_backup'): {fname}")
                    continue
                local_path = Path(root) / fname
                rel = local_path.relative_to(LOCAL_DIR)
                remote_subdir = REMOTE_DIR.rstrip('/') + '/' + str(rel.parent).replace('\\','/') if str(rel.parent) != '.' else REMOTE_DIR
                ensure_remote_dir(sftp, remote_subdir)
                logger.info(f'Processando arquivo: {local_path} -> {remote_subdir}')
                ok = upload_file(sftp, local_path, remote_subdir)
                if ok and DELETE_AFTER_UPLOAD:
                    try:
                        local_path.unlink()
                        logger.info(f'Arquivo local removido após upload: {local_path}')
                    except Exception as e:
                        logger.warning(f'Falha ao remover local {local_path}: {e}')
        logger.info('Processamento concluído')
    except Exception as e:
        logger.error(f'Erro no processo: {e}')
    finally:
        if sftp: 
            try: sftp.close()
            except Exception: pass
        if transport:
            try: transport.close()
            except Exception: pass

if __name__ == '__main__':
    process_once()

logrotate_sftp_uploader

/var/log/sftp_uploader/sftp_uploader.log {
    daily
    rotate 14
    compress
    missingok
    notifempty
    copytruncate
}

sftp-uploader.service

[Unit]
Description=SFTP Uploader Service
After=network.target
Wants=network-online.target

[Service]
Type=oneshot
ExecStart=/usr/bin/python3 /opt/sftp_uploader_app/sftp_uploader.py
User=root
Group=root
EnvironmentFile=/opt/sftp_uploader_app/.env
TimeoutStartSec=1800

sftp-uploader.timer

[Unit]
Description=Run SFTP uploader periodically

[Timer]
OnBootSec=2min
OnUnitActiveSec=60min
Unit=sftp-uploader.service

[Install]
WantedBy=timers.target

Conclusão

Este sistema fornece uma solução robusta e escalável para transferência automatizada de backups do S3 para servidores SFTP externos, com alta confiabilidade através de validação MD5, retry automático e logs detalhados.

As duas opções apresentadas (SSM Run Command e SSH direto) oferecem flexibilidade dependendo das necessidades de segurança e arquitetura da sua infraestrutura.

Dashboard Interativo de CVE's - AWS Inspector + Lambda + S3

Railander Marques — Thu, 06 Mar 2025 20:57:13 +0000

Este tutorial descreve como configurar uma solução na AWS para processar relatórios do AWS Inspector, armazená-los em um bucket S3, processá-los com uma função Lambda e gerar um dashboard HTML interativo.

Dashboard ScreenShot:

1. Resumo da Solução

A solução automatiza o processamento de relatórios de vulnerabilidades gerados pelo AWS Inspector. Aqui está uma visão geral:

AWS Inspector: Gera relatórios de vulnerabilidades em formato JSON e os armazena em um bucket S3 privado.
S3: Armazena os relatórios JSON no caminho /report e os relatórios HTML processados no caminho /final.
AWS KMS: Criptografa os dados no bucket S3 para segurança.
AWS Lambda: Processa os relatórios JSON usando Python 3.13, com a biblioteca AWS Lambda Powertools, e gera um dashboard HTML interativo.
Dashboard HTML: Exibe estatísticas e detalhes das vulnerabilidades encontradas em instâncias EC2 e imagens ECR.

A Lambda é acionada por eventos S3, processa apenas arquivos .json no caminho /report, e salva o resultado no caminho /final.

2. Diagrama da Solução

Fluxo:
1. AWS Inspector → Gera relatório JSON → S3 (Bucket: seu-bucket, Path: /report).
2. S3 → Evento notifica a Lambda.
3. Lambda → Lê o JSON, processa com KMS para descriptografia, gera HTML.
4. Lambda → Salva o HTML no S3 (Path: /final).
Componentes:
- AWS Inspector, S3, KMS, Lambda.
Conexões:
- Inspector usa KMS para criptografia.
- Lambda acessa S3 e KMS.

3. Configuração do AWS KMS para o AWS Inspector

O AWS Key Management Service (KMS) é usado para criptografar os relatórios do Inspector no S3. Abaixo está o passo a passo para criar e configurar uma chave KMS (Customer Managed Key - CMK).

Passo a Passo

Acesse o Console KMS:
- No console AWS, vá para Key Management Service (KMS).
- Clique em Create key (Criar chave) no canto superior direito.
Configure as Opções da Chave:
- Key type: Mantenha como Symmetric.
- Key usage: Escolha Encrypt and decrypt (Criptografar e descriptografar).
- Key material origin: Mantenha como KMS.
- Clique em Next.
Adicione Descrição e Tags:
- Alias: Insira um nome, por exemplo, inspector-report-key.
- Description: "Chave para criptografia de relatórios do AWS Inspector".
- Tags: Adicione tags opcionais (ex.: Project=Security).
- Clique em Next.
Definir Administradores da Chave:
- Na seção Key administrators, adicione os usuários/roles que gerenciarão a chave.
- Exemplo: Selecione uma role IAM como [ROLE_ADMINISTRATOR_MASKED].
- Esses administradores terão permissões para criar, excluir e gerenciar a chave.
Definir Usuários da Chave:
- Na seção Key usage permissions, adicione quem pode usar a chave para criptografia/descriptografia.
- Exemplo: Adicione [ROLE_ADMINISTRATOR_MASKED] para uso geral.
Revisar e Criar:
- Revise as configurações e clique em Create key.
- Anote o ARN da chave gerada (ex.: arn:aws:kms:us-east-1:[ACCOUNT_ID_MASKED]:key/[KEY_ID]).

Política da Chave (Key Policy)

A política abaixo define quem tem acesso à chave e como ela pode ser usada. Substitua [ACCOUNT_ID_MASKED] pelo seu ID de conta e [ROLE_ADMINISTRATOR_MASKED] pela sua role de administrador.

{
    "Version": "2012-10-17",
    "Id": "key-consolepolicy-3",
    "Statement": [
        {
            "Sid": "Enable IAM User Permissions",
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::[ACCOUNT_ID_MASKED]:root"
            },
            "Action": "kms:*",
            "Resource": "*"
        },
        {
            "Sid": "Allow access for Key Administrators",
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::[ACCOUNT_ID_MASKED]:role/[ROLE_ADMINISTRATOR_MASKED]"
            },
            "Action": [
                "kms:Create*",
                "kms:Describe*",
                "kms:Enable*",
                "kms:List*",
                "kms:Put*",
                "kms:Update*",
                "kms:Revoke*",
                "kms:Disable*",
                "kms:Get*",
                "kms:Delete*",
                "kms:TagResource",
                "kms:UntagResource",
                "kms:ScheduleKeyDeletion",
                "kms:CancelKeyDeletion",
                "kms:RotateKeyOnDemand"
            ],
            "Resource": "*"
        },
        {
            "Sid": "Allow use of the key",
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::[ACCOUNT_ID_MASKED]:role/[ROLE_ADMINISTRATOR_MASKED]"
            },
            "Action": [
                "kms:Encrypt",
                "kms:Decrypt",
                "kms:ReEncrypt*",
                "kms:GenerateDataKey*",
                "kms:DescribeKey"
            ],
            "Resource": "*"
        },
        {
            "Sid": "Allow attachment of persistent resources",
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::[ACCOUNT_ID_MASKED]:role/[ROLE_ADMINISTRATOR_MASKED]"
            },
            "Action": [
                "kms:CreateGrant",
                "kms:ListGrants",
                "kms:RevokeGrant"
            ],
            "Resource": "*",
            "Condition": {
                "Bool": {
                    "kms:GrantIsForAWSResource": "true"
                }
            }
        },
        {
            "Sid": "Allow Amazon Inspector to use the key",
            "Effect": "Allow",
            "Principal": {
                "Service": "inspector2.amazonaws.com"
            },
            "Action": [
                "kms:Decrypt",
                "kms:GenerateDataKey*"
            ],
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "[ACCOUNT_ID_MASKED]"
                },
                "ArnLike": {
                    "aws:SourceArn": "arn:aws:inspector2:us-east-1:[ACCOUNT_ID_MASKED]:report/*"
                }
            }
        }
    ]
}

Explicação:
- Root: Permite que a conta raiz gerencie a chave.
- Administradores: A role [ROLE_ADMINISTRATOR_MASKED] pode gerenciar a chave (ex.: rotacionar, excluir).
- Uso da Chave: A mesma role pode usá-la para criptografia/descriptografia.
- Recursos Persistentes: Permite grants para recursos AWS.
- Inspector: O serviço inspector2.amazonaws.com pode gerar chaves de dados e descriptografar, restrito à sua conta e relatórios.
Aplicar a Política:
- Após criar a chave, edite a Key Policy no console KMS e cole a política acima (com a adição do SID do AWS Inspector com seus ajustes).

4. Configuração do Bucket S3 e Lambda

Configuração do Bucket S3

Criar o Bucket:
- No console AWS, vá para S3 e clique em Create bucket.
- Nome: seu-bucket-inspector-report (substitua por um nome único).
- Região: Escolha sua região (ex.: us-east-1).
- Desative ACLs e mantenha o bucket privado (padrão).
Estrutura de Pastas:
- Crie manualmente os caminhos:
  - /report: Para relatórios JSON do Inspector.
  - /final: Para relatórios HTML gerados pela Lambda.
Bucket Policy:
- Na aba Permissions, edite a Bucket Policy e aplique:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "allow-inspector",
            "Effect": "Allow",
            "Principal": {
                "Service": "inspector2.amazonaws.com"
            },
            "Action": [
                "s3:PutObject",
                "s3:PutObjectAcl",
                "s3:AbortMultipartUpload"
            ],
            "Resource": "arn:aws:s3:::seu-bucket-inspector-report/*",
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "[ACCOUNT_ID_MASKED]"
                },
                "ArnLike": {
                    "aws:SourceArn": "arn:aws:inspector2:us-east-1:[ACCOUNT_ID_MASKED]:report/*"
                }
            }
        }
    ]
}

Explicação: Permite que o Inspector grave objetos no bucket, restrito à sua conta e relatórios.

Configuração da Lambda

Criar a Função Lambda:
- No console AWS, vá para Lambda e clique em Create function.
- Nome: process-inspector-report.
- Runtime: Python 3.13.
- Clique em Create.
- Clique em Configuration > Edit > Altere o Timeout para 1 min.
- Altere a memória para 300 megas.
Adicionar o Código:
- Coloque referências à empresa "SUA-EMPRESA":
  - No código, troque para seu bucket "seu-bucket-inspector-report".
  - No HTML, substitua o logo <img src="https://www.xpto.com.br/images/xpto-logo.svg" por <img src="https://seusite.com/logo.svg".
  - Troque "SUA-EMPRESA" por "Seu Projeto" no título e rodapé.
- Copie e cole o código fornecido (com essas alterações) na aba Code.
- Código Lambda para referência:

import json
import boto3
import logging
import os
from datetime import datetime
from collections import Counter, defaultdict
from typing import Dict, List, Any, Tuple
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.utilities.data_classes import S3Event, event_source

logger = Logger()
tracer = Tracer()

s3_client = boto3.client('s3')

@logger.inject_lambda_context
@tracer.capture_lambda_handler
@event_source(data_class=S3Event)
def lambda_handler(event: S3Event, context):
    """
    Lambda function to process AWS Inspector reports stored in S3.

    The function:
    1. Gets the report JSON file from the source bucket
    2. Processes the findings to extract relevant information
    3. Generates an HTML dashboard report
    4. Uploads the HTML report to the destination bucket
    """
    try:
        # Get the source bucket and key from the event
        source_bucket = event.bucket_name
        source_key = event.object_key

        if not source_key.endswith('.json'):
            logger.info(f"Skipping non-JSON file: {source_key}")
            return {
                'statusCode': 200,
                'body': 'Skipped non-JSON file'
            }

        # Get the object from S3
        logger.info(f"Processing file {source_key} from bucket {source_bucket}")
        response = s3_client.get_object(Bucket=source_bucket, Key=source_key)
        file_content = response['Body'].read().decode('utf-8')
        findings = json.loads(file_content).get('findings', [])

        if not findings:
            logger.warning("No findings in the report")
            return {
                'statusCode': 200,
                'body': 'No findings to process'
            }

        # Process the findings
        processed_data = process_findings(findings)

        # Generate HTML report
        html_content = generate_html_report(processed_data)

        # Define the destination key
        timestamp = datetime.now().strftime("%d%m%Y-%H%M%S")
        destination_bucket = "seu-bucket-inspector-report"
        destination_key = f"final/aws-inspector-report-{timestamp}.html"

        # Upload the HTML file to S3
        s3_client.put_object(
            Bucket=destination_bucket,
            Key=destination_key,
            Body=html_content,
            ContentType='text/html'
        )

        logger.info(f"Successfully uploaded report to s3://{destination_bucket}/{destination_key}")

        return {
            'statusCode': 200,
            'body': f'Successfully processed {len(findings)} findings and uploaded report to {destination_bucket}/{destination_key}'
        }

    except Exception as e:
        logger.exception("Error processing report")
        raise e

def process_findings(findings: List[Dict]) -> Dict:
    """
    Process the findings to extract relevant information for the report.

    Args:
        findings: List of finding dictionaries from the AWS Inspector report

    Returns:
        Dictionary with processed data for the HTML report
    """
    severity_counts = Counter()
    service_vulnerability_counts = defaultdict(int)

    ecr_findings = []
    ec2_findings = []

    # Process each finding
    for finding in findings:
        severity = finding.get('severity', 'UNKNOWN')
        severity_counts[severity] += 1

        # Determine the resource type and collect relevant findings
        resources = finding.get('resources', [])
        for resource in resources:
            resource_type = resource.get('type', '')

            if resource_type == 'AWS_ECR_CONTAINER_IMAGE':
                service_vulnerability_counts['ECR'] += 1
                details = resource.get('details', {}).get('awsEcrContainerImage', {})

                ecr_finding = {
                    'description': finding.get('description', ''),
                    'score': finding.get('epss', {}).get('score', 'N/A'),
                    'exploitAvailable': finding.get('exploitAvailable', 'N/A'),
                    'fixAvailable': finding.get('fixAvailable', 'N/A'),
                    'inspectorScore': finding.get('inspectorScore', 'N/A'),
                    'referenceUrls': finding.get('packageVulnerabilityDetails', {}).get('referenceUrls', []),
                    'sourceUrl': finding.get('packageVulnerabilityDetails', {}).get('sourceUrl', ''),
                    'vendorSeverity': finding.get('packageVulnerabilityDetails', {}).get('vendorSeverity', ''),
                    'vulnerabilityId': finding.get('packageVulnerabilityDetails', {}).get('vulnerabilityId', ''),
                    'imageHash': details.get('imageHash', ''),
                    'repositoryName': details.get('repositoryName', ''),
                    'title': finding.get('title', ''),
                    'severity': severity,
                    'vulnerability_details': []
                }

                # Extract vulnerable package details
                vuln_packages = finding.get('packageVulnerabilityDetails', {}).get('vulnerablePackages', [])
                for package in vuln_packages:
                    package_detail = {
                        'filePath': package.get('filePath', ''),
                        'type': package.get('packageManager', ''),
                        'fixedInVersion': package.get('fixedInVersion', ''),
                        'name': package.get('name', ''),
                        'packageManager': package.get('packageManager', ''),
                        'version': package.get('version', '')
                    }
                    ecr_finding['vulnerability_details'].append(package_detail)

                ecr_findings.append(ecr_finding)

            elif resource_type == 'AWS_EC2_INSTANCE':
                service_vulnerability_counts['EC2'] += 1
                details = resource.get('details', {}).get('awsEc2Instance', {})

                ec2_finding = {
                    'description': finding.get('description', ''),
                    'score': finding.get('epss', {}).get('score', 'N/A'),
                    'exploitAvailable': finding.get('exploitAvailable', 'N/A'),
                    'fixAvailable': finding.get('fixAvailable', 'N/A'),
                    'inspectorScore': finding.get('inspectorScore', 'N/A'),
                    'referenceUrls': finding.get('packageVulnerabilityDetails', {}).get('referenceUrls', []),
                    'sourceUrl': finding.get('packageVulnerabilityDetails', {}).get('sourceUrl', ''),
                    'vendorSeverity': finding.get('packageVulnerabilityDetails', {}).get('vendorSeverity', ''),
                    'vulnerabilityId': finding.get('packageVulnerabilityDetails', {}).get('vulnerabilityId', ''),
                    'id': resource.get('id', ''),
                    'title': finding.get('title', ''),
                    'name': resource.get('tags', {}).get('Name', ''),
                    'severity': severity,
                    'vulnerability_details': []
                }

                # Extract vulnerable package details
                vuln_packages = finding.get('packageVulnerabilityDetails', {}).get('vulnerablePackages', [])
                for package in vuln_packages:
                    package_detail = {
                        'filePath': package.get('filePath', ''),
                        'type': package.get('packageManager', ''),
                        'fixedInVersion': package.get('fixedInVersion', ''),
                        'name': package.get('name', ''),
                        'packageManager': package.get('packageManager', ''),
                        'version': package.get('version', '')
                    }
                    ec2_finding['vulnerability_details'].append(package_detail)

                ec2_findings.append(ec2_finding)

            else:
                service_vulnerability_counts['Other'] += 1

    # Sort findings by severity
    severity_order = {
        'CRITICAL': 0,
        'HIGH': 1,
        'MEDIUM': 2,
        'LOW': 3,
        'INFORMATIONAL': 4,
        'UNTRIAGED': 5,
        'UNKNOWN': 6
    }

    ecr_findings.sort(key=lambda x: severity_order.get(x['severity'], 999))
    ec2_findings.sort(key=lambda x: severity_order.get(x['severity'], 999))

    # Get top 5 services with most vulnerabilities
    top_services = dict(sorted(service_vulnerability_counts.items(), key=lambda item: item[1], reverse=True)[:5])

    # Get top 5 vulnerabilities
    vuln_counts = Counter(finding['packageVulnerabilityDetails'].get('vulnerabilityId', 'UNKNOWN') 
                         for finding in findings if 'packageVulnerabilityDetails' in finding)
    top_vulns = vuln_counts.most_common(5)
    top_vulns_data = [
        {'vuln': vuln, 'count': count}
        for vuln, count in top_vulns
    ]

    # Get top 5 servers (ECR repos + EC2 instances)
    server_counts = Counter()
    for finding in ecr_findings:
        server_counts[finding['repositoryName']] += 1
    for finding in ec2_findings:
        server_counts[finding['name'] or finding['id']] += 1
    top_servers = server_counts.most_common(5)
    top_servers_data = [
        {'server': server, 'count': count}
        for server, count in top_servers
    ]

    return {
        'timestamp': datetime.now().strftime("%d-%m-%Y"),
        'total_findings': len(findings),
        'severity_counts': severity_counts,
        'service_vulnerability_counts': service_vulnerability_counts,
        'service_data': [
            {'service': k, 'count': v}
            for k, v in top_services.items()
        ],
        'ecr_findings': ecr_findings,
        'ec2_findings': ec2_findings,
        'top_vulns_data': top_vulns_data,
        'top_servers_data': top_servers_data
    }

def generate_html_report(data: Dict) -> str:
    """
    Generate a modern HTML report for AWS Inspector findings with updated design.

    Args:
        data: Dictionary with processed finding data

    Returns:
        HTML content as a string
    """
    service_js_data = json.dumps(data['service_data'])
    top_vulns_js_data = json.dumps(data['top_vulns_data'])
    top_servers_js_data = json.dumps(data['top_servers_data'])

    # Organize ECR findings by repository
    ecr_by_repo = defaultdict(list)
    for finding in data['ecr_findings']:
        ecr_by_repo[finding['repositoryName']].append(finding)

    # Organize EC2 findings by instance
    ec2_by_instance = defaultdict(list)
    for finding in data['ec2_findings']:
        instance_key = finding['name'] or finding['id']
        ec2_by_instance[instance_key].append(finding)

    # Define the JavaScript section with escaped curly braces for objects
    script_content = """
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/js/bootstrap.bundle.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/chartjs-plugin-datalabels"></script>
    <script>
        function showSection(sectionId) {{
            document.querySelectorAll('.resource-section').forEach(function(section) {{
                section.style.display = 'none';
                section.style.overflow = 'visible';
                section.style.maxHeight = 'none';
                section.style.height = 'auto';
                section.style.flexShrink = '0'; // Ensure no flex shrinking
            }});

            // If sectionId is 'none', don't show any section (Clear Selection functionality)
            if (sectionId === 'none') {{
                return;
            }}

            const selectedSection = document.getElementById(sectionId);
            if (selectedSection) {{
                selectedSection.style.display = 'block';
                selectedSection.style.overflow = 'visible';
                selectedSection.style.maxHeight = 'none';
                selectedSection.style.height = 'auto';
                selectedSection.style.flexShrink = '0'; // Ensure no flex shrinking
            }} else {{
                console.error('Section not found: ' + sectionId);
            }}
        }}

        document.addEventListener('DOMContentLoaded', function() {{
            Chart.register(ChartDataLabels);

            const serviceData = JSON.parse('{0}');
            const servicesCtx = document.getElementById('servicesChart') ? document.getElementById('servicesChart').getContext('2d') : null;
            if (servicesCtx) {{
                new Chart(servicesCtx, {{
                    type: 'doughnut',
                    data: {{
                        labels: serviceData.map(function(d) {{ return d.service; }}),
                        datasets: [{{
                            data: serviceData.map(function(d) {{ return d.count || 0; }}),
                            backgroundColor: ['#6366f1', '#8b5cf6', '#22c55e', '#0ea5e9', '#475569'],
                            borderWidth: 2,
                            borderColor: '#fff',
                            hoverOffset: 10
                        }}]
                    }},
                    options: {{
                        cutout: '65%',
                        plugins: {{
                            legend: {{ position: 'bottom', labels: {{ padding: 20, font: {{ size: 12 }} }} }},
                            datalabels: {{
                                color: '#fff',
                                font: {{ weight: '600', size: 12 }},
                                formatter: function(value, ctx) {{
                                    const total = ctx.dataset.data.reduce(function(a, b) {{ return a + b; }}, 0);
                                    return total === 0 ? '0%' : ((value / total) * 100).toFixed(1) + '%';
                                }}
                            }}
                        }}
                    }},
                    plugins: [ChartDataLabels]
                }});
            }} else {{
                console.error('Canvas for servicesChart not found');
            }}

            const vulnsData = JSON.parse('{1}');
            const vulnsCtx = document.getElementById('vulnsChart') ? document.getElementById('vulnsChart').getContext('2d') : null;
            if (vulnsCtx) {{
                new Chart(vulnsCtx, {{
                    type: 'bar',
                    data: {{
                        labels: vulnsData.map(function(d) {{ return d.vuln.substring(0, 20) + (d.vuln.length > 20 ? '...' : ''); }}),
                        datasets: [{{
                            label: 'Count',
                            data: vulnsData.map(function(d) {{ return d.count || 0; }}),
                            backgroundColor: '#6366f1',
                            borderRadius: 8,
                            barThickness: 18
                        }}]
                    }},
                    options: {{
                        scales: {{
                            y: {{ beginAtZero: true, display: false }},
                            x: {{ grid: {{ display: false }} }}
                        }},
                        plugins: {{
                            legend: {{ display: false }},
                            datalabels: {{
                                anchor: 'end',
                                align: 'top',
                                color: '#0f172a',
                                font: {{ weight: '600', size: 12 }}
                            }}
                        }}
                    }},
                    plugins: [ChartDataLabels]
                }});
            }} else {{
                console.error('Canvas for vulnsChart not found');
            }}

            const serversData = JSON.parse('{2}');
            const serversCtx = document.getElementById('serversChart') ? document.getElementById('serversChart').getContext('2d') : null;
            if (serversCtx) {{
                new Chart(serversCtx, {{
                    type: 'bar',
                    data: {{
                        labels: serversData.map(function(d) {{ return d.server.substring(0, 20) + (d.server.length > 20 ? '...' : ''); }}),
                        datasets: [{{
                            label: 'Count',
                            data: serversData.map(function(d) {{ return d.count || 0; }}),
                            backgroundColor: '#22c55e',
                            borderRadius: 8,
                            barThickness: 18
                        }}]
                    }},
                    options: {{
                        scales: {{
                            y: {{ beginAtZero: true, display: false }},
                            x: {{ grid: {{ display: false }} }}
                        }},
                        plugins: {{
                            legend: {{ display: false }},
                            datalabels: {{
                                anchor: 'end',
                                align: 'top',
                                color: '#0f172a',
                                font: {{ weight: '600', size: 12 }}
                            }}
                        }}
                    }},
                    plugins: [ChartDataLabels]
                }});
            }} else {{
                console.error('Canvas for serversChart not found');
            }}
        }});
    </script>
    """.format(service_js_data, top_vulns_js_data, top_servers_js_data)

    # Main HTML content with updated CSS and Bootstrap override
    html = f'''<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AWS Inspector Dashboard - SUA-EMPRESA</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet">
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.2/css/all.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/chart.js@3.9.1/dist/chart.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/chartjs-plugin-datalabels@2.2.0/dist/chartjs-plugin-datalabels.min.js"></script>
    <style>
        :root {{
            --bg-color: linear-gradient(135deg, #eef2ff 0%, #dbeafe 100%);
            --card-bg: rgba(255, 255, 255, 0.95);
            --primary: #6366f1;
            --secondary: #475569;
            --text: #0f172a;
            --critical: #f43f5e;
            --high: #fb923c;
            --medium: #facc15;
            --low: #22c55e;
            --info: #0ea5e9;
            --shadow: 0 8px 32px rgba(31, 41, 55, 0.1);
            --transition: all 0.3s ease;
        }}

        body {{
            font-family: 'Inter', sans-serif;
            background: var(--bg-color);
            color: var(--text);
            margin: 0;
            padding: 0;
            min-height: 100vh;
        }}

        .header {{
            background: var(--primary);
            color: white;
            padding: 2rem 0;
            text-align: center;
            box-shadow: var(--shadow);
            position: relative;
            overflow: hidden;
        }}

        .header::before {{
            content: '';
            position: absolute;
            top: -50%;
            left: -50%;
            width: 200%;
            height: 200%;
            background: radial-gradient(circle, rgba(255, 255, 255, 0.2) 0%, transparent 70%);
            transform: rotate(30deg);
        }}

        .header-content {{
            position: relative;
            z-index: 1;
        }}

        .header img {{
            height: 50px;
            margin-bottom: 1rem;
        }}

        .header h1 {{
            font-size: 2.25rem;
            font-weight: 700;
            margin: 0;
            letter-spacing: -0.025em;
        }}

        .header p {{
            font-size: 1rem;
            opacity: 0.9;
            margin: 0.5rem 0 0;
        }}

        .container {{
            max-width: 1400px;
            margin: 0 auto;
            padding: 2rem;
            position: relative;
            z-index: 1;
        }}

        .stats-grid {{
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
            gap: 1.5rem;
            margin-top: -2.5rem;
            margin-bottom: 3rem;
        }}

        .stat-card {{
            background: var(--card-bg);
            border-radius: 1.25rem;
            padding: 1.5rem;
            box-shadow: var(--shadow);
            text-align: center;
            backdrop-filter: blur(10px);
            transition: var(--transition);
        }}

        .stat-card:hover {{
            transform: scale(1.03);
            box-shadow: 0 12px 40px rgba(31, 41, 55, 0.15);
        }}

        .stat-card h3 {{
            font-size: 2rem;
            font-weight: 700;
            margin: 0;
        }}

        .stat-card p {{
            font-size: 0.9rem;
            color: var(--secondary);
            margin: 0;
            text-transform: uppercase;
            letter-spacing: 0.05em;
        }}

        .charts-grid {{
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
            gap: 2rem;
            margin-bottom: 3rem;
        }}

        .chart-card {{
            background: var(--card-bg);
            border-radius: 1.25rem;
            padding: 1.5rem;
            box-shadow: var(--shadow);
            backdrop-filter: blur(10px);
        }}

        .chart-card h3 {{
            font-size: 1.25rem;
            font-weight: 600;
            margin-bottom: 1rem;
            color: var(--primary);
        }}

        .section-card {{
            background: var(--card-bg);
            border-radius: 1.25rem;
            padding: 2rem;
            box-shadow: var(--shadow);
            backdrop-filter: blur(10px);
            margin-bottom: 2rem;
            overflow: visible; /* Ensure section-card allows overflow */
            max-height: none; /* Remove any max-height constraint */
            height: auto; /* Allow natural height */
            min-height: 0; /* Ensure no minimum height restricts expansion */
        }}

        .section-card h2 {{
            font-size: 1.5rem;
            font-weight: 600;
            margin-bottom: 1.5rem;
            color: var(--text);
        }}

        .dropdown {{
            margin-bottom: 1.5rem;
            position: relative;
            z-index: 1000;
        }}

        .dropdown-toggle {{
            background: var(--primary);
            border: none;
            border-radius: 0.75rem;
            padding: 0.75rem 1.5rem;
            font-weight: 600;
            box-shadow: 0 4px 14px rgba(99, 102, 241, 0.3);
            transition: var(--transition);
        }}

        .dropdown-toggle:hover {{
            background: #4f46e5;
            box-shadow: 0 6px 20px rgba(99, 102, 241, 0.4);
            transform: translateY(-2px);
        }}

        .dropdown-menu {{
            border: none;
            border-radius: 0.75rem;
            box-shadow: var(--shadow);
            background: var(--card-bg);
            backdrop-filter: blur(10px);
            padding: 0.5rem;
            z-index: 1050;
        }}

        .dropdown-item {{
            border-radius: 0.5rem;
            padding: 0.5rem 1rem;
            transition: var(--transition);
        }}

        .dropdown-item:hover {{
            background: #eef2ff;
            color: var(--primary);
        }}

        .finding-card {{
            background: var(--card-bg);
            border-radius: 0.75rem;
            padding: 1.25rem;
            margin-bottom: 1rem;
            border-left: 5px solid;
            transition: var(--transition);
            overflow: visible; /* Ensure finding-card allows overflow */
            max-height: none; /* Remove any max-height constraint */
            height: auto; /* Allow natural height */
            min-height: 0; /* Ensure no minimum height restricts expansion */
            /* Override Bootstrap .d-flex to ensure child expansion */
            flex-direction: column !important; /* Stack children vertically */
            flex-wrap: wrap !important; /* Allow wrapping if needed */
            align-items: flex-start !important; /* Align children to start */
            flex-shrink: 0 !important; /* Prevent flex shrinking */
            flex-basis: auto !important; /* Allow natural size */
            flex-grow: 1 !important; /* Allow growth if needed */
        }}

        .finding-card:hover {{
            transform: translateY(-3px);
            box-shadow: 0 6px 20px rgba(31, 41, 55, 0.12);
        }}

        .resource-section {{
            overflow: visible; /* Ensure resource-section allows overflow */
            max-height: none; /* Remove any max-height constraint */
            height: auto; /* Allow natural height */
            min-height: 0; /* Ensure no minimum height restricts expansion */
            flex-shrink: 0; /* Prevent flex shrinking */
            flex-basis: auto; /* Allow natural size */
            flex-grow: 1; /* Allow growth if needed */
        }}

        .severity-badge {{
            padding: 0.35rem 0.8rem;
            font-size: 0.85rem;
            font-weight: 600;
            border-radius: 2rem;
            color: white;
            margin-right: 0.75rem;
            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
        }}

        .critical {{ border-color: var(--critical); }}
        .high {{ border-color: var(--high); }}
        .medium {{ border-color: var(--medium); }}
        .low {{ border-color: var(--low); }}
        .informational {{ border-color: var(--info); }}
        .untriaged, .unknown {{ border-color: var(--secondary); }}

        .badge-critical {{ background: var(--critical); }}
        .badge-high {{ background: var(--high); }}
        .badge-medium {{ background: var(--medium); color: var(--text); }}
        .badge-low {{ background: var(--low); }}
        .badge-info {{ background: var(--info); }}
        .badge-untriaged, .badge-unknown {{ background: var(--secondary); }}

        .details {{
            margin-top: 1rem;
            background: rgba(248, 250, 252, 0.9);
            padding: 1rem;
            border-radius: 0.5rem;
            border-left: 3px solid var(--primary);
            /* Ensure no constraints interfere */
            height: auto;
            max-height: none;
            min-height: 0;
            flex-shrink: 0; /* Prevent flex shrinking */
            flex-basis: auto; /* Allow natural size */
            flex-grow: 1; /* Allow growth if needed */
        }}

        .footer {{
            text-align: center;
            padding: 2rem;
            color: var(--secondary);
            font-size: 0.9rem;
            background: var(--card-bg);
            border-top-left-radius: 2rem;
            border-top-right-radius: 2rem;
            box-shadow: var(--shadow);
            backdrop-filter: blur(10px);
        }}

        @media (max-width: 768px) {{
            .header h1 {{ font-size: 1.75rem; }}
            .stat-card h3 {{ font-size: 1.5rem; }}
            .charts-grid {{ grid-template-columns: 1fr; }}
        }}
    </style>
</head>
<body>
    <header class="header">
        <div class="header-content">
            <img src="https://www.xpto.com.br/images/xpto-logo.svg" alt="SUA-EMPRESA">
            <h1>AWS Inspector Dashboard</h1>
            <p>Data do Relatório: {data['timestamp']}</p>
        </div>
    </header>

    <div class="container">
        <div class="stats-grid">
            <div class="stat-card">
                <h3 style="color: var(--primary)">{data['total_findings']}</h3>
                <p>Total Findings</p>
            </div>
            <div class="stat-card">
                <h3 style="color: var(--critical)">{data['severity_counts'].get('CRITICAL', 0) + data['severity_counts'].get('HIGH', 0)}</h3>
                <p>Critical/High</p>
            </div>
            <div class="stat-card">
                <h3 style="color: var(--medium)">{data['severity_counts'].get('MEDIUM', 0)}</h3>
                <p>Medium</p>
            </div>
            <div class="stat-card">
                <h3 style="color: var(--low)">{data['severity_counts'].get('LOW', 0) + data['severity_counts'].get('INFORMATIONAL', 0)}</h3>
                <p>Low/Info</p>
            </div>
        </div>

        <div class="charts-grid">
            <div class="chart-card">
                <h3>Top Services</h3>
                <canvas id="servicesChart" height="200"></canvas>
            </div>
            <div class="chart-card">
                <h3>Top 5 Vulnerabilities</h3>
                <canvas id="vulnsChart" height="200"></canvas>
            </div>
            <div class="chart-card">
                <h3>Top 5 Servers</h3>
                <canvas id="serversChart" height="200"></canvas>
            </div>
        </div>

        <!-- ECR Section -->
        <div class="section-card">
            <h2><i class="fab fa-docker me-2"></i> ECR Findings ({len(data['ecr_findings'])})</h2>
            <div class="dropdown">
                <button class="btn dropdown-toggle" type="button" id="ecrDropdown" data-bs-toggle="dropdown" aria-expanded="false">
                    Select Repository
                </button>
                <ul class="dropdown-menu" aria-labelledby="ecrDropdown">
                    <li><a class="dropdown-item" href="#" onclick="showSection('none')">Clear Selection</a></li>
                    <li><a class="dropdown-item" href="#ecr-all" onclick="showSection('ecr-all')">All Repositories</a></li>
'''
    for repo in ecr_by_repo.keys():
        html += f'''                    <li><a class="dropdown-item" href="#ecr-{repo}" onclick="showSection('ecr-{repo}')">{repo}</a></li>'''

    html += f'''                </ul>
            </div>
            <div id="ecr-all" class="resource-section" style="display:none;">
'''
    for repo, findings in ecr_by_repo.items():
        for i, finding in enumerate(findings):
            severity_class = finding['severity'].lower() if finding['severity'] else 'unknown'
            html += f'''
                <div class="finding-card {severity_class}">
                    <div class="d-flex justify-content-between align-items-center">
                        <div>
                            <span class="severity-badge badge-{severity_class}">{finding['severity']}</span>
                            <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a> - <strong>{finding['title']}</strong>
                            <p class="mb-0 text-muted">Repo: {repo}</p>
                        </div>
                    </div>
                    <div class="details">
                        <p>{finding['description']}</p>
                        <p><strong>ID:</strong> <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a></p>
                        <p><strong>Fix:</strong> {finding['fixAvailable']}</p>
                    </div>
                </div>
'''
    html += f'''            </div>
'''
    for repo in ecr_by_repo.keys():
        html += f'''            <div id="ecr-{repo}" class="resource-section" style="display:none;">'''
        for i, finding in enumerate(ecr_by_repo[repo]):
            severity_class = finding['severity'].lower() if finding['severity'] else 'unknown'
            html += f'''
                <div class="finding-card {severity_class}">
                    <div class="d-flex justify-content-between align-items-center">
                        <div>
                            <span class="severity-badge badge-{severity_class}">{finding['severity']}</span>
                            <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a> - <strong>{finding['title']}</strong>
                        </div>
                    </div>
                    <div class="details">
                        <p>{finding['description']}</p>
                        <p><strong>ID:</strong> <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a></p>
                        <p><strong>Fix:</strong> {finding['fixAvailable']}</p>
                    </div>
                </div>
'''
        html += f'''            </div>'''

    html += f'''        </div>

        <!-- EC2 Section -->
        <div class="section-card">
            <h2><i class="fas fa-server me-2"></i> EC2 Findings ({len(data['ec2_findings'])})</h2>
            <div class="dropdown">
                <button class="btn dropdown-toggle" type="button" id="ec2Dropdown" data-bs-toggle="dropdown" aria-expanded="false">
                    Select Instance
                </button>
                <ul class="dropdown-menu" aria-labelledby="ec2Dropdown">
                    <li><a class="dropdown-item" href="#" onclick="showSection('none')">Clear Selection</a></li>
                    <li><a class="dropdown-item" href="#ec2-all" onclick="showSection('ec2-all')">All Instances</a></li>
'''
    for instance in ec2_by_instance.keys():
        html += f'''                    <li><a class="dropdown-item" href="#ec2-{instance}" onclick="showSection('ec2-{instance}')">{instance}</a></li>'''

    html += f'''                </ul>
            </div>
            <div id="ec2-all" class="resource-section" style="display:none;">
'''
    for instance, findings in ec2_by_instance.items():
        for i, finding in enumerate(findings):
            severity_class = finding['severity'].lower() if finding['severity'] else 'unknown'
            html += f'''
                <div class="finding-card {severity_class}">
                    <div class="d-flex justify-content-between align-items-center">
                        <div>
                            <span class="severity-badge badge-{severity_class}">{finding['severity']}</span>
                            <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a> - <strong>{finding['title']}</strong>
                            <p class="mb-0 text-muted">Instance: {instance}</p>
                        </div>
                    </div>
                    <div class="details">
                        <p>{finding['description']}</p>
                        <p><strong>ID:</strong> <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a></p>
                        <p><strong>Fix:</strong> {finding['fixAvailable']}</p>
                    </div>
                </div>
'''
    html += f'''            </div>
'''
    for instance in ec2_by_instance.keys():
        html += f'''            <div id="ec2-{instance}" class="resource-section" style="display:none;">'''
        for i, finding in enumerate(ec2_by_instance[instance]):
            severity_class = finding['severity'].lower() if finding['severity'] else 'unknown'
            html += f'''
                <div class="finding-card {severity_class}">
                    <div class="d-flex justify-content-between align-items-center">
                        <div>
                            <span class="severity-badge badge-{severity_class}">{finding['severity']}</span>
                            <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a> - <strong>{finding['title']}</strong>
                        </div>
                    </div>
                    <div class="details">
                        <p>{finding['description']}</p>
                        <p><strong>ID:</strong> <a href="{finding['sourceUrl']}" target="_blank">{finding['vulnerabilityId']}</a></p>
                        <p><strong>Fix:</strong> {finding['fixAvailable']}</p>
                    </div>
                </div>
'''
        html += f'''            </div>'''

    html += f'''        </div>
    </div>

    <footer class="footer">
        <p>© {datetime.now().year} SUA-EMPRESA - AWS Inspector Vulnerability Report</p>
    </footer>
'''

    # Concatenate the script content at the end
    html += script_content + '''
</body>
</html>
'''
    return html

Configurar Layers:

Clique em Layers → Add a layer.
Escolha AWS provided e procure por AWSLambdaPowertools.
Selecione a versão mais recente para Python 3.13 e adicione.

Permissões IAM:

Crie uma IAM policy para a Lambda:
- No console IAM, crie uma policy com:
  - Política S3 + KMS:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject"
            ],
            "Resource": "arn:aws:s3:::seu-bucket-inspector-report/*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "kms:Decrypt",
                "kms:GenerateDataKey"
            ],
            "Resource": "arn:aws:kms:us-east-1:[ACCOUNT_ID_MASKED]:key/[KEY_ID]"
        }
    ]
}

Anexe essa permissão criada à Role da Lambda (alterando o ARN da para sua KMS criada).

Configurar o Gatilho S3:

Na Lambda, clique em Add trigger.
Escolha S3.
Bucket: seu-bucket-inspector-report.
Event type: All object create events.
Prefix: report/.
Suffix: .json.
Clique em Add.

Pronto! Agora você deve gerar o relatório do KMS, em .json, para o s3://seu-bucket-inspector-report/report/ e buscar o HTML gerado no path seu-bucket-inspector-report/final/.

Stream Dynamo para RDS Mysql

Railander Marques — Sun, 22 Dec 2024 15:56:24 +0000

Visão Geral

Esta implementação tem como objetivo capturar eventos de alteração na tabela DynamoDB “account_answers_full” (atraves de lambda) e replicar esses eventos para um banco de dados relacional RDS (MySQL). Para isso, utiliza duas funções Lambda que se comunicam através de uma fila SQS da AWS.

Uma Lambda captura eventos de alteração na tabela DynamoDB 'account_answers_full' e os envia como mensagens para uma fila SQS, utilizando uma DLQ para gerenciar mensagens não processadas e permitir o reprocessamento dos dados em caso de falhas temporárias. Em seguida, outra Lambda consome essas mensagens da SQS, estabelece conexão com o RDS via ENI (recomenda-se utilizar RDS Proxy para gerenciar essas conexões), processa e executa operações correspondentes no banco de dados RDS MySQL.

Passo 1: DynamoDB para SQS

Tabela DynamoDB:
- Nome: account_answers_full
- Índices Globais Secundários:
  - uid-question-index: uid (Número), question (Número)
  - uid-section_id-index: uid (Número), section_id (Número)
  - uid-usection_id-index: uid (Número), usection_id (Número)\n
Trigger Lambda 1 (dynamo-to-sqs-connector):
- Esta Lambda é acionada por eventos de alteração na tabela DynamoDB (INSERT, MODIFY, REMOVE).
- Extrai os detalhes do evento, empacota-os em uma mensagem e os envia para uma fila SQS ==(Use fila FIFO, fila standard pode causar problemas de duplicação)==.

Código da Lambda 1:

const { SendMessageCommand, SQSClient } = require("@aws-sdk/client-sqs");

const sqs = new SQSClient({});
const queueUrl = process.env.SQS_QUEUE_URL; // VARIÁVEL DE AMBIENTE COM SQS FIFO - SOMENTE FIFO FUNCIONA NESSE CÓDIGO

exports.handler = async (event) => {
  for (const record of event.Records) {
    if (['INSERT', 'MODIFY', 'REMOVE'].includes(record.eventName)) {
      try {
        const item = record.dynamodb.NewImage ?? record.dynamodb.OldImage
        const message = {
          eventName: record.eventName,
          dynamodb: record.dynamodb
        };

        // Usando usection_id, section_id e question como parte do MessageGroupId
        const usection_id = item.usection_id.N;
        const section_id = item.section_id.N;
        const question = item.question.N;
        const messageGroupId = `usection-${usection_id}-section-${section_id}-question-${question}`;


        const command = new SendMessageCommand({
          QueueUrl: queueUrl,
          MessageBody: JSON.stringify(message),
          MessageGroupId: messageGroupId
        });

        await sqs.send(command);

        console.info(`Message sent to SQS: ${JSON.stringify(message)}`);
      } catch (error) {
        console.error(`Error sending message to SQS: ${error.message}`, { error });
      }
    }
  }

  console.info('Lambda execution completed');
};

[lambda_1_eprep-9c1a3420-b362-42e0-8493-033e3e0e99b1.zip 740]
https://github.com/aldeiacloud/StreamDynamoMysql/raw/refs/heads/main/lambda_1_eprep-9c1a3420-b362-42e0-8493-033e3e0e99b1.zip

Variáveis de Ambiente:
- SQS_QUEUE_URL: URL da fila SQS para onde as mensagens são enviadas. (Perceba que tem o Endpoint).

Logs:

ScreenShot Trigger 1:

Passo 2: SQS para RDS

Trigger Lambda 2 (sqs-to-rds-connector):
- Acionada por mensagens na fila SQS FIFO (com DLQ) enviadas pela Lambda 1.
- Processa as mensagens, extrai os detalhes do evento DynamoDB e executa operações correspondentes no banco de dados RDS.

Código da Lambda 2:

const { SQSClient, SendMessageCommand, ReceiveMessageCommand, DeleteMessageCommand } = require("@aws-sdk/client-sqs");
const mysql = require('mysql');
const { promisify } = require('util')

// Configuração personalizada para aumentar o timeout nas tentativas de conexão
// Configuração do cliente DLQ com o endpoint HTTP
const dlqEndpointUrl = process.env.DLQ_ENDPOINT_URL;

const sqs = new SQSClient({
    maxRetries: 10,
    httpOptions: {
        timeout: 120000
    }
});

// Carrega as credenciais do RDS a partir das variáveis de ambiente
const dbConfig = {
    user: process.env.RDS_USERNAME,
    password: process.env.RDS_PASSWORD,
    host: process.env.RDS_HOST,
    database: process.env.RDS_DATABASE,
    port: process.env.RDS_PORT
};

// Função para conectar ao banco de dados MySQL com tentativas de retry
async function connectToMySQL(retryAttempts = 5, delay = 120000) {
    for (let attempt = 0; attempt < retryAttempts; attempt++) {
        try {
            const connection = mysql.createConnection(dbConfig);
            await promisify(connection.connect).call(connection);
            return connection;
        } catch (err) {
            console.error("Error connecting to MySQL", { error: err.message });
            if (attempt < retryAttempts - 1) {
                console.info(`Retrying in ${delay / 1000} seconds...`);
                await new Promise(res => setTimeout(res, delay));
            } else {
                throw err;
            }
        }
    }
}

// Função para processar um registro do SQS
async function processRecord(record) {
    let connection;
    try {
        console.info("Processing SQS message:", record);

        const messageBody = JSON.parse(record.body);
        console.info(`Parsed message body: ${record.body}`);

        const eventName = messageBody.eventName;
        const dynamodb = messageBody.dynamodb;

        const keys = dynamodb.Keys;
        const newImage = dynamodb?.NewImage || {};

        const usectionId = keys.usection_id.N;
        const question = keys.question.N;
        const sectionId = newImage?.section_id ? newImage?.section_id?.N : "";

        connection = await connectToMySQL();
        const query = promisify(connection.query).bind(connection);

        let sqlScript, sqlValue;

        // Realiza a operação correspondente com base no evento
        if (eventName === "INSERT") {
            sqlScript = "INSERT INTO account_answers (usection_id, question, section_id) VALUES (?, ?, ?)";
            sqlValue = [usectionId, question, sectionId];
            await query(sqlScript, sqlValue);
            console.info("Record inserted successfully into account_answers table", { sqlValue });

        } else if (eventName === "MODIFY") {
            sqlScript = "UPDATE account_answers SET section_id = ? WHERE usection_id = ? AND question = ?";
            sqlValue = [sectionId, usectionId, question];
            await query(sqlScript, sqlValue);
            console.info("Record modified successfully in account_answers table", { sqlValue });

        } else if (eventName === "REMOVE") {
            sqlScript = "DELETE FROM account_answers WHERE usection_id = ? AND question = ?";
            sqlValue = [usectionId, question];
            await query(sqlScript, sqlValue);
            console.info("Record removed successfully from account_answers table", { sqlValue });
        }

    } catch (err) {
        console.error("Error processing SQS message", JSON.stringify(err));
        throw new Error(err ?? "Unknow error processing SQS message");
    } finally {
        if (connection) {
            connection.end();
        }
    }
}

// Função para reprocessar mensagens da DLQ com timeout e intervalo entre tentativas
async function reprocessDlqMessages(timeoutSeconds = 300, retryIntervalSeconds = 1) {
    try {
        console.info("Starting reprocessing of DLQ messages");

        const startTime = Date.now();

        while (true) {
            // Verifica se o tempo máximo de execução foi atingido
            if ((Date.now() - startTime) > (timeoutSeconds * 1000)) {
                console.info("Timeout reached for DLQ reprocessing");
                break;
            }

            try {
                const command = new ReceiveMessageCommand({
                    QueueUrl: dlqEndpointUrl,
                    MaxNumberOfMessages: 10,
                    WaitTimeSeconds: 10
                });

                const response = await sqs.send(command)

                const messages = response.Messages || [];
                if (messages.length === 0) {
                    console.info("No more messages in DLQ");
                    break;
                }

                for (const message of messages) {
                    try {
                        await processWithRetry(message)
                        console.log('deu certo o retry dlq')
                        const command = new DeleteMessageCommand({
                            QueueUrl: dlqEndpointUrl,
                            ReceiptHandle: message.ReceiptHandle
                        });
                        await sqs.send(command);
                    } catch (err) {
                        console.error("Failed to reprocess message from DLQ", { message, error: err.message });
                    }
                }

                // Aguarda antes de tentar a próxima iteração para evitar sobrecarga no endpoint
                await new Promise(res => setTimeout(res, retryIntervalSeconds * 1000));

            } catch (err) {
                console.error("Error receiving messages from DLQ", { error: err.message });
                await new Promise(res => setTimeout(res, retryIntervalSeconds * 1000));  // Espera antes de tentar novamente em caso de falha
            }
        }

        console.info("Reprocessing of DLQ messages completed");

    } catch (err) {
        console.error("Error reprocessing DLQ messages", { error: err.message });
        throw err;
    }
}

// Função para processar um registro com tentativas de retry
async function processWithRetry(record, retries = 3, backoffInSeconds = 2) {
    let attempt = 0;
    while (attempt < retries) {
        try {
            await processRecord(record);
            console.log('sucesso')
            return;
        } catch (err) {
            attempt++;
            console.error(`Attempt ${attempt} failed: ${JSON.stringify(err)}`);
            if (attempt < retries) {
                await new Promise(res => setTimeout(res, backoffInSeconds * 1000 * (2 ** (attempt - 1))));  // Exponential backoff
            }else {
                throw err;
            }
        }
    }
}

// Função Lambda Handler
exports.handler = async (event, context) => {
    console.info("Starting the lambda_handler function for SQS to RDS");

    try {
        for (const record of event.Records) {
            try {
                await processWithRetry(record);
            } catch (err) {
                // Envia mensagem para DLQ para reprocessamento posterior
                console.error("Failed to process record after retries, sending to DLQ");
                try {
                    const command = new SendMessageCommand({
                        QueueUrl: dlqEndpointUrl,
                        MessageBody: JSON.stringify(record)
                    });

                    await sqs.send(command)
                } catch (err) {
                    console.error("Failed to send message to DLQ", { error: err.message });
                }
            }
        }

        // Reprocessa mensagens da DLQ se houver
        await reprocessDlqMessages();

    } catch (err) {
        console.error("Error processing records from SQS", { error: err.message });
    }

    console.info("lambda_handler function execution completed for SQS to RDS");
};

[ae3075c0-896a-4473-acc2-b0e151a1a280.zip 2628477]
https://github.com/aldeiacloud/StreamDynamoMysql/raw/refs/heads/main/ae3075c0-896a-4473-acc2-b0e151a1a280.zip

:::info
Explicação e Resumo do Código

:::

1. Importações e Configurações Iniciais

const { SQSClient, SendMessageCommand, ReceiveMessageCommand, DeleteMessageCommand } = require("@aws-sdk/client-sqs");
const mysql = require('mysql');
const { promisify } = require('util');

SQSClient e comandos: Importa classes para interagir com o SQS, que é um serviço de fila gerenciado da AWS.
mysql: Para conexão com um banco de dados MySQL.
promisify: Utilizado para transformar funções que usam callbacks em funções que retornam promessas, facilitando o uso de async/await.

2. Configuração do Cliente SQS


const dlqEndpointUrl = process.env.DLQ_ENDPOINT_URL;

const sqs = new SQSClient({
    maxRetries: 10,
    httpOptions: {
        timeout: 120000
    }
});

dlqEndpointUrl: URL da Dead Letter Queue (DLQ), onde mensagens falhas são enviadas.
SQSClient: Configura o cliente com um número máximo de tentativas e um timeout para requisições HTTP.

3. Configuração do Banco de Dados


const dbConfig = {
    user: process.env.RDS_USERNAME,
    password: process.env.RDS_PASSWORD,
    host: process.env.RDS_HOST,
    database: process.env.RDS_DATABASE,
    port: process.env.RDS_PORT
};

Carrega as credenciais do RDS (Relational Database Service) a partir de variáveis de ambiente.

4. Conexão ao Banco de Dados


async function connectToMySQL(retryAttempts = 5, delay = 120000) {
    // Tenta conectar ao MySQL com múltiplas tentativas
}

Tenta criar uma conexão com o banco de dados e, se falhar, aguarda um tempo antes de tentar novamente.

5. Processamento de Mensagens do SQS


async function processRecord(record) {
    let connection;
    try {
        const messageBody = JSON.parse(record.body);
        const eventName = messageBody.eventName;
        const dynamodb = messageBody.dynamodb;
        const keys = dynamodb.Keys;
        const newImage = dynamodb?.NewImage || {};

        const usectionId = keys.usection_id.N;
        const question = keys.question.N;
        const sectionId = newImage?.section_id ? newImage?.section_id?.N : "";

        connection = await connectToMySQL();
        const query = promisify(connection.query).bind(connection);

        let sqlScript, sqlValue;

        // Operações com base no tipo de evento
        if (eventName === "INSERT") {
            sqlScript = "INSERT INTO account_answers (usection_id, question, section_id) VALUES (?, ?, ?)";
            sqlValue = [usectionId, question, sectionId];
            await query(sqlScript, sqlValue);
            console.info("Record inserted successfully");

        } else if (eventName === "MODIFY") {
            sqlScript = "UPDATE account_answers SET section_id = ? WHERE usection_id = ? AND question = ?";
            sqlValue = [sectionId, usectionId, question];
            await query(sqlScript, sqlValue);
            console.info("Record modified successfully");

        } else if (eventName === "REMOVE") {
            sqlScript = "DELETE FROM account_answers WHERE usection_id = ? AND question = ?";
            sqlValue = [usectionId, question];
            await query(sqlScript, sqlValue);
            console.info("Record removed successfully");
        }

    } catch (err) {
        console.error("Error processing SQS message", JSON.stringify(err));
        throw new Error(err ?? "Unknown error processing SQS message");
    } finally {
        if (connection) {
            connection.end();
        }
    }
}

processRecord: Recebe uma mensagem do SQS e processa com base no tipo de evento (INSERT, MODIFY, REMOVE).
- INSERT: Adiciona um novo registro na tabela account_answers.
- MODIFY: Atualiza um registro existente.
- REMOVE: Remove um registro existente.
A conexão com o MySQL é encerrada após a operação.

6. Reprocessamento de Mensagens da DLQ


async function reprocessDlqMessages(timeoutSeconds = 300, retryIntervalSeconds = 1) {
    // Tenta reprocessar mensagens na DLQ
}

Este método tenta ler mensagens da DLQ e processá-las novamente.
Se a reprocessamento falhar, loga um erro e continua tentando.

7. Tentativas de Processamento com Retry


async function processWithRetry(record, retries = 3, backoffInSeconds = 2) {
    // Tenta processar um registro várias vezes com um intervalo entre as tentativas
}

Implementa um mecanismo de retry com um backoff exponencial, permitindo que o sistema tente processar mensagens que falharam antes.\n

8. Função Lambda Handler


exports.handler = async (event, context) => {
    // Função principal que é chamada quando a Lambda é acionada
}

Processa cada registro recebido do SQS.
Se uma mensagem falhar após as tentativas, ela é enviada para a DLQ.
Também tenta reprocessar mensagens da DLQ ao final do processamento.

Resumo

Inserção: Quando um evento de inserção ocorre, um novo registro é adicionado ao banco.
Atualização: Para eventos de modificação, um registro existente é atualizado.
Remoção: Para eventos de remoção, um registro específico é deletado.
SQS e DLQ: Mensagens são enviadas para uma fila (SQS) e, se falharem várias vezes, são redirecionadas para uma DLQ para posterior análise.
Conexões: O código gerencia as conexões ao MySQL, garantindo que sejam fechadas após o uso.

Screenshots:

Observações:
:::warning

Colocar todas as permissões dos serviços necessárias, incluindo SQS, Dynamo, CloudWatch...
A Lambda 2, que conecta no banco de dados, precisa ter uma ENI, para fazer a conexão (Verificar SG)
Esse tutorial esta configurado para fazer insert, delete ou update em 1 tabela especifica em 3 colunas, caso necessite de mais, precisa ajustar as 2 lambdas no tratamento do SQS e no script SQL.

:::

Configuração do SQS e Teste de Carga:

Filas SQS Fifo

Fila 1 - SQS

Fila 2 - SQS DLQ

:::info
Ponderações:

:::

Lambda 2

Duração baixa e quantidade de invocação alta, 100% de sucesso.

Quantidade Máxima de conexão no RDS:

Lambda 1

Percebemos um total de concurrents maior no envio do dado do Dynamo para o SQS, sem erros no envio, invocações muito altas, alimentando a fila de SQS, que contem uma outra fila DLQ para reprocessar em caso de falha temporária.

:::success
Fiz outro teste de carga, reiniciando o banco de dados antes da execução e a arquitetura conseguiu inserir as 10 mil linhas após o banco iniciar:

:::

(…)

:::success
Resultados e Observações:

Não tive problemas de muitas conexões no RDS ou problemas no SQS:

1- Endpoint SQS para evitar timeout no endpoint para conexão no SQS, tanto na DLQ tanto na principal;

2- Escolha da quantidade de concurrency da lambda 2, quanto maior, mais conexões no RDS;

3- Garantir o uso da fila do tipo Fifo com desduplicação ativa.

4- Fiz um teste reiniciando o banco de dados e os dados foram enviados para o banco após reiniciar.

:::

Exportar Voip para AWS EC2 - .vmdk ou .ova

Railander Marques — Sun, 22 Dec 2024 02:40:31 +0000

1- Vamos usar como exemplo neste tutorial uma .iso FreePBX para exportação.

Baixar .iso do FreePBX no endereço: https://downloads.freepbxdistro.org/ISO/
Neste tutorial, usei essa .iso: https://downloads.freepbxdistro.org/ISO/SNG7-FPBX-64bit-2011-5.iso

2- Usaremos o Virtual Box para instalar a .iso em .vmdk e converter para .ova

![Coloque o nome | clique em NEXT]

![Neste caso, vou usar 4GB de ram para instalação | clique em NEXT]

![Escolha criar novo disco | clique em CREATE]

![Escolha VMDK | clique em NEXT]

![Deixe em "Dynamically allocated | clique em NEXT]

![Aloque cerca de 20GB para a máquina virtual | clique em CREATE]

![Clique em SETTINGS]

![Escolha uma quantidade razoável de cores para configurarmos a máquina virtual]

![Habilitar uma placa de rede NAT]

![Clique em Storage > Empty > Icone de CD > Choose a disk file]

![Escolha a .iso a ser instalada | clique em OPEN e OK na janela anterior]

![Clique em START]

![Caso pergunte qual midia para iniciar a máquina virtual, selecione a .iso a ser instalada | clique em START]

![Neste tutorial usaremos a versão 16 | aperte ENTER]

![Escolha a opção "Graphical Installation - Output to VGA" | aperte ENTER]

![Escolha a opção "FreePBX Standard | aperte ENTER]

![............ Aguarde a instalação ............]

![Clique em "ROOT PASSWORD" para configurar uma senha para o ROOT]

![Defina uma senha e clique em DONE]

![Com a senha de root configurada, aguarde até o final da instalação]

![Clique em REBOOT]

![Desligue a maquina virtual | clique em OK]

![Com a máquina virtual em STOP | clique em SETTINGS]

![Clique em Storage > clique na ISO atachada > Clique no ícone de CD > Remove Disk from Virtual Drive > Inicie o VOIP]

![Ao iniciar, logue como usuario "root" e a senha escolhida na instalação]

3- Agora que a máquina virtual está instalada, vamos instalar o AWS SSM Agent para acesso ao terminal via AWS Console

Neste caso, instalaremos o SSM para região de Virgínia (us-east-1) na AWS, seguindo a documentação da AWS.

https://docs.aws.amazon.com/systems-manager/latest/userguide/agent-install-rhel.html

sudo yum install -y https://s3.us-east-1.amazonaws.com/amazon-ssm-us-east-1/latest/linux_amd64/amazon-ssm-agent.rpm
sudo systemctl enable amazon-ssm-agent
sudo systemctl start amazon-ssm-agent
sudo systemctl status amazon-ssm-agent

4- Agora podemos desligar a máquina virtual.

Execute o comando:

shutdown now

5- Vamos exportar a maquina virtual para .ova

![File > Export Appliance]

![Escolha FreePBX | clique em NEXT]

![Escolha o destino | clique em NEXT]

![Clique em EXPORT]

6- Criar bucket privado e fazer upload do arquivo.ovapara o AWS S3

Faça o upload do arquivo .ova para dentro do bucket criado

7- Vamos criar uma politica com o nome trust-policy.jsonno computador local

Execute o comando abaixo:

cat > "trust-policy.json" << "EOF"
{
   "Version": "2012-10-17",
   "Statement": [
      {
         "Effect": "Allow",
         "Principal": { "Service": "vmie.amazonaws.com" },
         "Action": "sts:AssumeRole",
         "Condition": {
            "StringEquals":{
               "sts:Externalid": "vmimport"
            }
         }
      }
   ]
}
EOF

![Output do comando acima]

8- Vamos criar uma Role com o nome vmimport utilizando o arquivo trust-policy.json

Para isso necessitamos exportar uma credencial programática com permissão “AdministratorAccess”* em seu terminal.

![Comando para exportar credencial no terminal, necessário instalar o AWS CLI https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html]

Execute o comando abaixo:

aws iam create-role --role-name vmimport --assume-role-policy-document "file://trust-policy.json"

9- Variáveis que iremos alterar nos arquivos a seguir

nome_do_seu_bucket="aldeiacloud"
# Apontar o diretorio/arquivo.ova
S3Key="diretorio-local/FreePBX.ova"

Esta política será anexada à Role vmimport criada na etapa anterior
Vamos alterar o bucket_name para o nome do seu bucket no AWS S3

role-policy.json

echo '{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Action":[
            "s3:GetBucketLocation",
            "s3:GetObject",
            "s3:ListBucket" 
         ],
         "Resource":[
            "arn:aws:s3:::'nome_do_seu_bucket'",
            "arn:aws:s3:::'nome_do_seu_bucket'/*"
         ]
      },
      {
         "Effect":"Allow",
         "Action":[
            "ec2:ModifySnapshotAttribute",
            "ec2:CopySnapshot",
            "ec2:RegisterImage",
            "ec2:Describe*"
         ],
         "Resource":"*"
      }
   ]
}
' | sudo tee role-policy.json

Execute o comando:

aws iam put-role-policy --role-name vmimport \
                        --policy-name vmimport \
                        --policy-document "file://role-policy.json"

10- Iniciar tarefa de exportação da .ova

Em nosso caso, iremos executar o seguinte comando para criarmos o arquivo

Execute o comando:

echo '[
  {                                          
    "Description": "FreePBX",
    "Format": "ova",
    "UserBucket": {
        "S3Bucket": "'nome_do_seu_bucket'",
        "S3Key": "'diretorio-local/FreePBX.ova'"
    }
}]
' > containers.json

Iniciar exportação

Execute o comando:

aws ec2 import-image --description "FreePBX" --disk-containers "file://containers.json"

CHECAGEM DA TASK

Verifique o status dos trabalhos de importação de VM

aws ec2 describe-import-image-tasks --import-task-ids "import-ami-xxxxxxxxxxxxxxxxx"

[Status 3]

![Status 4 | COMPLETED]

Alarme Dynamo Throttle Events - Discord

Railander Marques — Sun, 22 Dec 2024 02:34:50 +0000

Essa configuração monitora determinadas métricas de uma tabela DynamoDB e envia uma notificação para um canal Discord se forem detectados eventos de throttling.

Primeiro Passo - Configuração da Lambda

Amostragem geral:

Runtime:

Variáveis de Ambiente:

Resource-based - Policy Statements (Importante para o alarme conseguir triggar a lambda)

Configuração da resource-based policy: (ARN do alarme criado para triggar a lambda)

Permissões necessárias:

Código Lambda:

import json
import boto3
import requests
import os
from datetime import datetime, timedelta

# Configurações do Discord Webhook
DISCORD_WEBHOOK_URL = os.environ['DISCORD_WEBHOOK_URL']

# Cliente boto3 para o CloudWatch
cloudwatch = boto3.client('cloudwatch')

def send_discord_notification(message):
    data = {
        "content": message
    }
    response = requests.post(DISCORD_WEBHOOK_URL, json=data)
    if response.status_code != 204:
        raise ValueError(f"Falha ao enviar notificação para o Discord: {response.status_code}, {response.text}")

def lambda_handler(event, context):
#    print("Evento recebido:", json.dumps(event))
    print(event) 
    # Métricas a serem monitoradas
    metrics_to_monitor = [
        'WriteThrottleEvents',
        'ReadThrottleEvents'
    ]

    # Nome da tabela DynamoDB a ser monitorada
    table_name = os.environ['TABLE_NAME']
    print(f"Tabela a ser monitorada: {table_name}")

    for metric_name in metrics_to_monitor:
        print(f"Verificando métrica: {metric_name}")

        response = cloudwatch.get_metric_statistics(
            Namespace='AWS/DynamoDB',
            MetricName=metric_name,
            Dimensions=[
                {
                    'Name': 'TableName',
                    'Value': table_name
                }
            ],
            StartTime=datetime.utcnow() - timedelta(minutes=5),
            EndTime=datetime.utcnow(),
            Period=60,
            Statistics=['Sum']
        )

        print(f"Resposta da CloudWatch: {response}")

        data_points = response.get('Datapoints', [])
        if data_points:
            for point in data_points:
                print(f"Ponto de dados: {point}")
                if point['Sum'] > 0:
                    message = f"Evento de throttle ({metric_name}) detectado na tabela {table_name} com {int(point['Sum'])} eventos."
                    print(f"Enviando mensagem para o Discord: {message}")
                    try:
                        send_discord_notification(message)
                    except Exception as e:
                        print(f"Erro ao enviar notificação para o Discord: {e}")
                    else:
                        print("Notificação enviada com sucesso.")
                else:
                    print(f"Nenhum evento de throttle detectado para {metric_name}.")
        else:
            print(f"Nenhum ponto de dados encontrado para {metric_name}.")

    print("Processo de verificação concluído.")

    return {
        'statusCode': 200,
        'body': json.dumps('Notificações enviadas se algum evento de throttle for detectado.')
    }

Download Lambda Code [dynamo-throttle-events.zip]
https://github.com/aldeiacloud/DynamoThrottleEvents/raw/refs/heads/main/ecbb053f-e092-4059-b39d-f8f184166e76.zip

Função principal (lambda_handler):
- Recebe o evento e o contexto quando acionada.
- Define as métricas a serem monitoradas: WriteThrottleEvents e ReadThrottleEvents.
- Obtém o nome da tabela DynamoDB a ser monitorada a partir das variáveis de ambiente.
- Para cada métrica, consulta o CloudWatch para obter estatísticas sobre eventos de throttling nos últimos 5 minutos.
- Analisa os pontos de dados retornados:
  - Se houver eventos de throttling (soma maior que 0), envia uma notificação para o Discord com detalhes.
  - Caso contrário, indica que não foram detectados eventos de throttling.
- Finaliza o processo de verificação e retorna um status de sucesso.

A função envia uma notificação ao Discord somente se detectar eventos de throttling nas métricas monitoradas da tabela DynamoDB especificada.

Segundo Passo - Configuração do Alarme CloudWatch

Amostragem geral:

Table Name / Statistic / Period:

Condições:

Lambda action:

Feito, agora quando o alarme triggar algum throttle na leitura ou escrita da tabela configurada no alerta e nas variáveis do lambda, ele vai enviar para o grupo de texto no discord.

Após forçar um throttle, conseguimos receber o evento no Discord:

AWS Inspector - Notificação CVE - EC2 e ECR

Railander Marques — Wed, 17 Jul 2024 11:16:30 +0000

Neste tutorial, vamos explicar como criar e configurar uma função Lambda na AWS que captura eventos do AWS Inspector via SNS, formata esses eventos em um email detalhado e os envia via AWS SES para um destinatário específico.

Passos:

Criar a Função Lambda:
Primeiro, você precisa criar uma função Lambda na AWS. A função Lambda será acionada pelos eventos gerados pelo AWS Inspector através do SNS.
- Acesse o Console da AWS.
- Vá para o serviço Lambda.
- Clique em "Criar função".
- Configure o nome, a runtime (Python 3.12 ou superior recomendado) e deixe as permissões de execução padrão inicialmente. (Depois adicione AmazonEC2ReadOnlyAccess, AmazonSESFullAccess, AmazonSNSReadOnlyAccess e AmazonEC2ContainerRegistryReadOnly)
- Defina como 1 minuto o timeout da lambda.
Configurar Gatilho do SNS:
- Após criar a função Lambda, adicione um gatilho SNS.
- Selecione o tópico SNS que recebe os eventos do AWS Inspector.
- Exemplo da CloudWatch Rule de detecção do Inspector que envia para o SNS:

{
  "source": ["aws.inspector2"],
  "detail-type": ["Inspector2 Finding"],
  "detail": {
    "severity": ["HIGH", "MEDIUM", "CRITICAL"],
    "status": ["ACTIVE", "CLOSED", "SUPRESSED"]
  }
}

Configure a função lambda para ser acionada por novas mensagens no tópico SNS.

Variáveis de ambiente:

Implementar o Código da Função Lambda:

Troque o nome da empresa do código, para a empresa que deseja configurar o alerta.

import json
import boto3
import os

# Inicialize os clientes da AWS
ses_client = boto3.client('ses')
ec2_client = boto3.client('ec2')
ecr_client = boto3.client('ecr')

def send_email(subject, body):
    # Função para enviar o email usando SES
    response = ses_client.send_email(
        Source=os.environ['SOURCE_EMAIL'],
        Destination={
            'ToAddresses': [os.environ['TARGET_EMAIL']]
        },
        Message={
            'Subject': {
                'Data': subject,
                'Charset': 'UTF-8'
            },
            'Body': {
                'Html': {
                    'Data': body,
                    'Charset': 'UTF-8'
                }
            }
        }
    )
    print(f"Email enviado com sucesso: {response}")

def lambda_handler(event, context):
    for record in event['Records']:
        sns_message = json.loads(record['Sns']['Message'])
        detail = sns_message.get('detail', {})

        # Detalhes do evento
        title = detail.get('title', 'N/A')
        description = detail.get('description', 'N/A').replace('\n', '<br>')
        severity = detail.get('severity', 'N/A')
        status = detail.get('status', 'N/A')
        finding_arn = detail.get('findingArn', 'N/A')
        first_observed = detail.get('firstObservedAt', 'N/A')
        last_observed = detail.get('lastObservedAt', 'N/A')
        updated_at = detail.get('updatedAt', 'N/A')
        vulnerability_id = detail.get('packageVulnerabilityDetails', {}).get('vulnerabilityId', 'N/A')

        resources = detail.get('resources', [])

        for resource in resources:
            resource_type = resource.get('type', '')

            if resource_type == 'AWS_EC2_INSTANCE':
                # Detalhes da instância EC2
                instance_id = resource.get('id', 'N/A')
                instance_name = get_ec2_instance_name(instance_id)
                instance_profile = resource.get('details', {}).get('awsEc2Instance', {}).get('iamInstanceProfileArn', 'N/A')
                image_id = resource.get('details', {}).get('awsEc2Instance', {}).get('imageId', 'N/A')
                ipv4_addresses = ', '.join(resource.get('details', {}).get('awsEc2Instance', {}).get('ipV4Addresses', []))
                platform = resource.get('details', {}).get('awsEc2Instance', {}).get('platform', 'N/A')
                instance_type = resource.get('details', {}).get('awsEc2Instance', {}).get('type', 'N/A')

                # Construir corpo do email para EC2
                email_subject = f"Alerta de Segurança - EMPRESA XPTO - {instance_name} - {title}"
                email_body = build_ec2_email_body(instance_name, title, description, instance_id, instance_profile, image_id, ipv4_addresses, platform, instance_type, severity, status, finding_arn, first_observed, last_observed, updated_at, vulnerability_id)
                send_email(email_subject, email_body)

            elif resource_type == 'AWS_ECR_CONTAINER_IMAGE':
                # Detalhes da imagem no ECR
                repository_name = resource.get('details', {}).get('awsEcrContainerImage', {}).get('repositoryName', 'N/A')
                image_digest = resource.get('details', {}).get('awsEcrContainerImage', {}).get('imageDigest', 'N/A')
                image_tags = ', '.join(resource.get('details', {}).get('awsEcrContainerImage', {}).get('imageTags', []))
                pushed_at = resource.get('details', {}).get('awsEcrContainerImage', {}).get('pushedAt', 'N/A')
                architecture = resource.get('details', {}).get('awsEcrContainerImage', {}).get('architecture', 'N/A')
                platform = resource.get('details', {}).get('awsEcrContainerImage', {}).get('platform', 'N/A')

                # Construir corpo do email para ECR
                email_subject = f"Alerta de Segurança - EMPRESA XPTO - {repository_name} - {title}"
                email_body = build_ecr_email_body(repository_name, title, description, image_digest, image_tags, pushed_at, architecture, platform, severity, status, finding_arn, first_observed, last_observed, updated_at, vulnerability_id)
                send_email(email_subject, email_body)

def get_ec2_instance_name(instance_id):
    # Função para obter o nome da instância EC2 a partir do ID da instância
    instance_name = "N/A"
    if instance_id != "N/A":
        ec2_response = ec2_client.describe_instances(InstanceIds=[instance_id])
        tags = ec2_response['Reservations'][0]['Instances'][0].get('Tags', [])
        for tag in tags:
            if tag['Key'] == 'Name':
                instance_name = tag['Value']
                break
    return instance_name

def build_ec2_email_body(instance_name, title, description, instance_id, instance_profile, image_id, ipv4_addresses, platform, instance_type, severity, status, finding_arn, first_observed, last_observed, updated_at, vulnerability_id):
    # Função para construir o corpo do email para eventos de EC2
    email_body = f"""
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Alerta de Segurança - EMPRESA XPTO PCI-DSS</title>
    <style>
        body {{
            font-family: Arial, sans-serif;
            line-height: 1.6;
            margin: 20px;
            background-color: #f5f5f5;
        }}
        h2 {{
            background-color: #333;
            color: #fff;
            padding: 10px;
            border-radius: 5px 5px 0 0;
            margin-top: 0;
        }}
        p {{
            margin-bottom: 20px;
            color: #555;
            padding: 0 10px;
        }}
        table {{
            width: 100%;
            border-collapse: collapse;
            border: 1px solid #ddd;
            border-radius: 5px;
            margin-top: 20px;
        }}
        th, td {{
            padding: 10px;
            text-align: left;
            border-bottom: 1px solid #ddd;
        }}
        th {{
            background-color: #f2f2f2;
            color: #333;
            font-weight: bold;
        }}
        tr:nth-child(even) {{
            background-color: #f9f9f9;
        }}
        td:first-child, th:first-child {{
            width: 30%;
            min-width: 120px;
            font-weight: bold;
        }}
    </style>
</head>
<body>
    <h2>Alerta de Segurança - EMPRESA XPTO PCI-DSS</h2>
    <p>Recebemos uma nova notificação de vulnerabilidade no AWS Inspector:</p>
    <table>
        <tr>
            <th colspan="2">Detalhes da Vulnerabilidade</th>
        </tr>
        <tr>
            <td><b>Título</b></td>
            <td>{title}</td>
        </tr>
        <tr>
            <td><b>Descrição</b></td>
            <td>{description}</td>
        </tr>
        <tr>
            <td><b>ID da Vulnerabilidade</b></td>
            <td>{vulnerability_id}</td>
        </tr>
        <tr>
            <td><b>Severidade</b></td>
            <td>{severity}</td>
        </tr>
        <tr>
            <td><b>Status</b></td>
            <td>{status}</td>
        </tr>
        <tr>
            <td><b>Encontrado em</b></td>
            <td>{first_observed}</td>
        </tr>
        <tr>
            <td><b>Última Observação</b></td>
            <td>{last_observed}</td>
        </tr>
        <tr>
            <td><b>Atualizado em</b></td>
            <td>{updated_at}</td>
        </tr>
        <tr>
            <th colspan="2">Detalhes da Instância EC2</th>
        </tr>
        <tr>
            <td><b>ID da Instância</b></td>
            <td>{instance_id}</td>
        </tr>
        <tr>
            <td><b>Nome da Instância</b></td>
            <td>{instance_name}</td>
        </tr>
        <tr>
            <td><b>Perfil IAM</b></td>
            <td>{instance_profile}</td>
        </tr>
        <tr>
            <td><b>ID da Imagem</b></td>
            <td>{image_id}</td>
        </tr>
        <tr>
            <td><b>Endereços IPv4</b></td>
            <td>{ipv4_addresses}</td>
        </tr>
        <tr>
            <td><b>Plataforma</b></td>
            <td>{platform}</td>
        </tr>
        <tr>
            <td><b>Tipo da Instância</b></td>
            <td>{instance_type}</td>
        </tr>
    </table>
    <p>Para mais informações, acesse o painel do AWS Inspector.</p>
</body>
</html>
"""
    return email_body

def build_ecr_email_body(repository_name, title, description, image_digest, image_tags, pushed_at, architecture, platform, severity, status, finding_arn, first_observed, last_observed, updated_at, vulnerability_id):
    # Função para construir o corpo do email para eventos de ECR
    email_body = f"""
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Alerta de Segurança - EMPRESA XPTO PCI-DSS</title>
    <style>
        body {{
            font-family: Arial, sans-serif;
            line-height: 1.6;
            margin: 20px;
            background-color: #f5f5f5;
        }}
        h2 {{
            background-color: #333;
            color: #fff;
            padding: 10px;
            border-radius: 5px 5px 0 0;
            margin-top: 0;
        }}
        p {{
            margin-bottom: 20px;
            color: #555;
            padding: 0 10px;
        }}
        table {{
            width: 100%;
            border-collapse: collapse;
            border: 1px solid #ddd;
            border-radius: 5px;
            margin-top: 20px;
        }}
        th, td {{
            padding: 10px;
            text-align: left;
            border-bottom: 1px solid #ddd;
        }}
        th {{
            background-color: #f2f2f2;
            color: #333;
            font-weight: bold;
        }}
        tr:nth-child(even) {{
            background-color: #f9f9f9;
        }}
        td:first-child, th:first-child {{
            width: 30%;
            min-width: 120px;
            font-weight: bold;
        }}
    </style>
</head>
<body>
    <h2>Alerta de Segurança - EMPRESA XPTO PCI-DSS</h2>
    <p>Recebemos uma nova notificação de vulnerabilidade no AWS Inspector:</p>
    <table>
        <tr>
            <th colspan="2">Detalhes da Vulnerabilidade</th>
        </tr>
        <tr>
            <td><b>Título</b></td>
            <td>{title}</td>
        </tr>
        <tr>
            <td><b>Descrição</b></td>
            <td>{description}</td>
        </tr>
        <tr>
            <td><b>ID da Vulnerabilidade</b></td>
            <td>{vulnerability_id}</td>
        </tr>
        <tr>
            <td><b>Severidade</b></td>
            <td>{severity}</td>
        </tr>
        <tr>
            <td><b>Status</b></td>
            <td>{status}</td>
        </tr>
        <tr>
            <td><b>Encontrado em</b></td>
            <td>{first_observed}</td>
        </tr>
        <tr>
            <td><b>Última Observação</b></td>
            <td>{last_observed}</td>
        </tr>
        <tr>
            <td><b>Atualizado em</b></td>
            <td>{updated_at}</td>
        </tr>
        <tr>
            <th colspan="2">Detalhes da Imagem no ECR</th>
        </tr>
        <tr>
            <td><b>Nome do Repositório</b></td>
            <td>{repository_name}</td>
        </tr>
        <tr>
            <td><b>Digest da Imagem</b></td>
            <td>{image_digest}</td>
        </tr>
        <tr>
            <td><b>Tags da Imagem</b></td>
            <td>{image_tags}</td>
        </tr>
        <tr>
            <td><b>Arquitetura</b></td>
            <td>{architecture}</td>
        </tr>
        <tr>
            <td><b>Plataforma</b></td>
            <td>{platform}</td>
        </tr>
        <tr>
            <td><b>Enviado em</b></td>
            <td>{pushed_at}</td>
        </tr>
    </table>
    <p>Para mais informações, acesse o painel do AWS Inspector.</p>
</body>
</html>
"""
    return email_body

Teste de eventos:

Um teste para ser feito para EC2:

{
  "Records": [
    {
      "EventSource": "aws:sns",
      "EventVersion": "1.0",
      "EventSubscriptionArn": "arn:aws:sns:sa-east-1:530929948444:AWS-CVE-Inspector:d07cd6d8-2f8d-40c9-af6a-ecc4266e0e70",
      "Sns": {
        "Type": "Notification",
        "MessageId": "175a2902-7430-5515-bc29-7613ec172f9f",
        "TopicArn": "arn:aws:sns:sa-east-1:530929948444:AWS-CVE-Inspector",
        "Subject": null,
        "Message": "{\"version\":\"0\",\"id\":\"e7b5cb0b-b7b1-6390-fdcf-4ba7c5cf572d\",\"detail-type\":\"Inspector2 Finding\",\"source\":\"aws.inspector2\",\"account\":\"530929948444\",\"time\":\"2024-07-17T09:58:46Z\",\"region\":\"sa-east-1\",\"resources\":[\"i-09cc55700f9369d04\"],\"detail\":{\"awsAccountId\":\"530929948444\",\"description\":\"In the Linux kernel, the following vulnerability has been resolved: usb: udc: remove warning when queue disabled ep It is possible trigger below warning message from mass storage function, WARNING: CPU: 6 PID: 3839 at drivers/usb/gadget/udc/core.c:294 usb_ep_queue+0x7c/0x104 pc : usb_ep_queue+0x7c/0x104 lr : fsg_main_thread+0x494/0x1b3c Root cause is mass storage function try to queue request from main thread, but other thread may already disable ep when function disable. As there is no function failure in the driver, in order to avoid effort to fix warning, change WARN_ON_ONCE() in usb_ep_queue() to pr_debug().\",\"epss\":{\"score\":4.4E-4},\"exploitAvailable\":\"NO\",\"findingArn\":\"arn:aws:inspector2:sa-east-1:530929948444:finding/7c4806a9e2c4b7230d865d1c96d20b11\",\"firstObservedAt\":\"Tue Jul 16 21:45:59.629 UTC 2024\",\"fixAvailable\":\"YES\",\"lastObservedAt\":\"Tue Jul 16 21:45:59.629 UTC 2024\",\"packageVulnerabilityDetails\":{\"cvss\":[],\"referenceUrls\":[\"https://git.kernel.org/linus/2a587a035214fa1b5ef598aea0b81848c5b72e5e(6.9-rc2)\",\"https://ubuntu.com/security/notices/USN-6817-3\",\"https://git.kernel.org/stable/c/df5cbb908f1687e8ab97e222a16b7890d5501acf\",\"https://git.kernel.org/stable/c/99731076722eb7ed26b0c87c879da7bb71d24290\",\"https://git.kernel.org/stable/c/2b002c308e184feeaeb72987bca3f1b11e5f70b8\",\"https://git.kernel.org/stable/c/68d951880d0c52c7f13dcefb5501b69b8605ce8c\",\"https://ubuntu.com/security/notices/USN-6878-1\",\"https://git.kernel.org/stable/c/30511676eb54d480d014352bf784f02577a10252\",\"https://ubuntu.com/security/notices/USN-6816-1\",\"https://ubuntu.com/security/notices/USN-6817-2\",\"https://ubuntu.com/security/notices/USN-6817-1\",\"https://www.cve.org/CVERecord?id=CVE-2024-35822\",\"https://ubuntu.com/security/notices/USN-6896-1\",\"https://ubuntu.com/security/notices/USN-6898-1\",\"https://git.kernel.org/stable/c/3e944ddc17c042945d983e006df7860687a8849a\",\"https://git.kernel.org/stable/c/f74c5e0b54b02706d9a862ac6cddade30ac86bcf\",\"https://git.kernel.org/stable/c/2a587a035214fa1b5ef598aea0b81848c5b72e5e\",\"https://git.kernel.org/stable/c/36177c2595df12225b95ce74eb1ac77b43d5a58c\"],\"relatedVulnerabilities\":[\"USN-6816-1\",\"USN-6817-1\",\"USN-6817-2\",\"USN-6817-3\",\"USN-6896-1\",\"USN-6898-1\",\"USN-6878-1\"],\"source\":\"UBUNTU_CVE\",\"sourceUrl\":\"https://people.canonical.com/~ubuntu-security/cve/2024/CVE-2024-35822.html\",\"vendorCreatedAt\":\"Fri May 17 14:15:00.000 UTC 2024\",\"vendorSeverity\":\"medium\",\"vulnerabilityId\":\"CVE-2024-35822\",\"vulnerablePackages\":[{\"arch\":\"X86_64\",\"epoch\":0,\"fixedInVersion\":\"0:5.15.0-116.126\",\"name\":\"linux-libc-dev\",\"packageManager\":\"OS\",\"release\":\"113.123\",\"remediation\":\"apt-get update && apt-get upgrade\",\"version\":\"5.15.0\"}]},\"remediation\":{\"recommendation\":{\"text\":\"None Provided\"}},\"resources\":[{\"details\":{\"awsEc2Instance\":{\"iamInstanceProfileArn\":\"arn:aws:iam::530929948444:instance-profile/ScoutSuite\",\"imageId\":\"ami-0228d19e5bf7dc391\",\"ipV4Addresses\":[\"172.30.0.243\"],\"ipV6Addresses\":[],\"keyName\":\"b23_lnx_sec\",\"launchedAt\":\"Tue Oct 03 03:48:54.000 UTC 2023\",\"platform\":\"UBUNTU_22_04\",\"subnetId\":\"subnet-0cf6115b2cf95ddf8\",\"type\":\"c6a.xlarge\",\"vpcId\":\"vpc-00a09194848c6e5d6\"}},\"id\":\"i-09cc55700f9369d04\",\"partition\":\"aws\",\"region\":\"sa-east-1\",\"tags\":{\"BackupEC2\":\"true\",\"Name\":\"SRV-LNX-SEC\"},\"type\":\"AWS_EC2_INSTANCE\"}],\"severity\":\"MEDIUM\",\"status\":\"CLOSED\",\"title\":\"CVE-2024-35822 - linux-libc-dev\",\"type\":\"PACKAGE_VULNERABILITY\",\"updatedAt\":\"Wed Jul 17 09:58:46.559 UTC 2024\"}}",
        "Timestamp": "2024-07-17T09:59:03.737Z",
        "SignatureVersion": "1",
        "Signature": "nVpeMS7rnD1WUTmp04BwMC64Dp1Db9WagxLI+Lzlray1YTnpEtgezAoguYJY4DnPrTsouX67vq7plVEnWj5oxeTDR+GFlSCGDlzM/pQf5AO8haAuWuFWatTYudcwdma9cNnSMzmVyQ8Kqn4tJOudvPaIneuL20uxstvdLYVBb/9TznCBY2N+YBwv4BLGZEcqnY35Vf6TeDcSZInSk90z8f/9tXUdFtgHo7WuMzWAX6Eoen70XE3e1SLwE6gSTSa+mSFzCfD8Tj2n+SXQB9wE/ZTLR7UBEFmdjkvmJ2WgE810JUKFRzFFH7cWLp3gyRcXhXH5G1bTsFmc1R4Jo/ZAaQ==",
        "SigningCertUrl": "https://sns.sa-east-1.amazonaws.com/SimpleNotificationService-60eadc530605d63b8e62a523676ef735.pem",
        "UnsubscribeUrl": "https://sns.sa-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:sa-east-1:530929948444:AWS-CVE-Inspector:d07cd6d8-2f8d-40c9-af6a-ecc4266e0e70",
        "MessageAttributes": {}
      }
    }
  ]
}

Um teste para ser feito para ECR:

{
  "Records": [
    {
      "Sns": {
        "Message": "{\"detail\":{\"title\":\"High Vulnerability in ECR Image\",\"description\":\"A high severity vulnerability was detected in the container image.\",\"severity\":\"HIGH\",\"status\":\"ACTIVE\",\"findingArn\":\"arn:aws:inspector:us-east-1:123456789012:finding/finding-id\",\"firstObservedAt\":\"2024-07-16T10:00:00Z\",\"lastObservedAt\":\"2024-07-16T10:00:00Z\",\"updatedAt\":\"2024-07-16T10:00:00Z\",\"packageVulnerabilityDetails\":{\"vulnerabilityId\":\"CVE-2024-1234\"},\"resources\":[{\"type\":\"AWS_ECR_CONTAINER_IMAGE\",\"id\":\"arn:aws:ecr:us-east-1:123456789012:repository/my-repository\",\"details\":{\"awsEcrContainerImage\":{\"repositoryName\":\"my-repository\",\"imageDigest\":\"sha256:example1234\",\"imageTags\":[\"latest\"],\"pushedAt\":\"2024-07-15T10:00:00Z\",\"architecture\":\"amd64\",\"platform\":\"linux\"}}}]}}"
      }
    }
  ]
}

Notificações:

Exemplo de email fake EC2 enviado para a caixa de email

Exemplo de email fake ECR enviado para a caixa de email

Explicação do Código:

A função lambda_handler é o ponto de entrada da Lambda, que recebe eventos do SNS.
Os detalhes da vulnerabilidade são extraídos da mensagem JSON recebida.
Detalhes específicos da instância EC2 ou ECR são recuperados usando o cliente EC2 ou ECR.
Um email é construído em HTML para fornecer informações detalhadas sobre a vulnerabilidade e a instância.
O email é enviado usando o cliente SES da AWS.

Configure IOT Fake - Python MQQT - Test IoTCore

Railander Marques — Tue, 16 Jul 2024 12:52:07 +0000

Configure IOT Fake - Python MQQT - Test IoTCore

1. Configurar o IoT Core no AWS

Criar uma "Thing" no IoT Core:

No console do AWS IoT Core, vá para "Manage" e depois "Things".
Clique em "Create things" e crie uma "Thing".

Criar Certificados:

Após criar a "Thing", crie um certificado para ela.
Baixe os arquivos de certificado e chave privada.
Anexe uma política ao certificado que permita operações de publicação.

2. Criar o Script Python para Simular o Dispositivo

Instale a biblioteca paho-mqtt:

pip install paho-mqtt

Crie um script Python para simular o envio de dados de geolocalização:

import paho.mqtt.client as mqtt
import ssl
import json
import time
import random

# Configurações AWS IoT
client_id = "geolocation_device"
endpoint = "<seu-endpoint-iot>.iot.<sua-regiao>.amazonaws.com"
root_ca = "/path/to/AmazonRootCA1.pem"
certificate = "/path/to/device-certificate.pem.crt"
private_key = "/path/to/private.pem.key"
topic = "geolocation/topic"

# Callback para quando a conexão for estabelecida
def on_connect(client, userdata, flags, rc):
    print("Conectado com o código: " + str(rc))
    client.subscribe(topic)

# Callback para quando uma mensagem for recebida
def on_message(client, userdata, msg):
    print("Mensagem recebida: " + msg.topic + " -> " + msg.payload.decode())

# Inicializa o cliente MQTT
client = mqtt.Client(client_id)
client.tls_set(root_ca, certfile=certificate, keyfile=private_key, tls_version=ssl.PROTOCOL_TLSv1_2)
client.on_connect = on_connect
client.on_message = on_message

# Conecta ao AWS IoT Core
client.connect(endpoint, 8883, 60)

# Função para simular dados de geolocalização
def simulate_geolocation_data():
    data = {
        'latitude': round(random.uniform(-90.0, 90.0), 6),
        'longitude': round(random.uniform(-180.0, 180.0), 6),
        'timestamp': int(time.time())
    }
    return data

# Publica dados de geolocalização em intervalos regulares
while True:
    geolocation_data = simulate_geolocation_data()
    client.publish(topic, json.dumps(geolocation_data))
    print(f"Publicado: {geolocation_data}")
    time.sleep(5)  # Espera 5 segundos antes de enviar novos dados

# Mantém a conexão e espera por mensagens
client.loop_forever()

3. Configurar uma Instância EC2

Criar e Configurar a Instância EC2:

Lançar uma instância EC2:
- No console do EC2, escolha "Launch Instance".
- Selecione uma AMI (Amazon Machine Image), como Amazon Linux 2.
- Escolha o tipo de instância (t2.micro é suficiente para testes).
- Configure as opções da instância e adicione armazenamento, se necessário.
- Configure um security group para permitir acesso SSH (porta 22) e saída (outbound) para todos os destinos (por padrão, todas as saídas são permitidas).
Conectar à Instância EC2:
- Conecte-se à sua instância EC2 usando SSH.

   ssh -i "seu-par-de-chaves.pem" ec2-user@seu-endereço-ec2

Instalar Python e Bibliotecas Necessárias:
- Atualize os pacotes e instale o Python se não estiver instalado.

   sudo yum update -y
   sudo yum install -y python3
   sudo pip3 install paho-mqtt

Transferir o Script para a Instância EC2:
- Transfira o script Python e os arquivos de certificado para a instância EC2 usando SCP (Secure Copy).

   scp -i "seu-par-de-chaves.pem" /caminho/para/o/script.py ec2-user@seu-endereço-ec2:/home/ec2-user/
   scp -i "seu-par-de-chaves.pem" /caminho/para/AmazonRootCA1.pem ec2-user@seu-endereço-ec2:/home/ec2-user/
   scp -i "seu-par-de-chaves.pem" /caminho/para/device-certificate.pem.crt ec2-user@seu-endereço-ec2:/home/ec2-user/
   scp -i "seu-par-de-chaves.pem" /caminho/para/private.pem.key ec2-user@seu-endereço-ec2:/home/ec2-user/

Executar o Script na Instância EC2:
- Navegue até o diretório onde você transferiu os arquivos e execute o script Python.

   cd /home/ec2-user/
   python3 script.py

Verificação

No console do AWS IoT Core: Verifique se os dados estão sendo publicados no tópico correto.
Logs no EC2: Verifique a saída no terminal para confirmar que os dados estão sendo enviados corretamente.

Seguindo esses passos, você conseguirá simular um dispositivo IoT que envia dados de geolocalização para o AWS IoT Core a partir de uma instância EC2. Isso permite que você teste e valide o fluxo de dados em um ambiente realista.

DEV Community: Railander Marques

Resposta a incidente: EC2 com minerador e credencial da role vazada, da contenção à reconstrução

1. Objetivo

2. Sinais típicos

3. Antes de começar

4. Passo 1: Travar a instância

5. Passo 2: Isolar a rede (do jeito certo)

6. Passo 3: Invalidar as credenciais da role

7. Passo 4: O que o atacante fez com as credenciais

8. Passo 5: Coletar dados voláteis

8.1 Memória

9. Passo 6: Snapshots e envio para a conta de forense

10. Passo 7: Análise do disco

10.1 Linha do tempo

10.2 O minerador

10.3 Por onde entrou

10.4 Roubo de credencial pelo IMDS

11. Passo 8: Erradicar e reconstruir

12. Passo 9: Para não acontecer de novo

13. Referências

Athena via ODBC sem access key: IAM Roles Anywhere para Power BI e Excel fora da AWS

1. Objetivo

2. Por que não access key (e por que não Identity Center)

3. Arquitetura

4. Pré-requisitos

5. Passo 1: Workgroup dedicado

6. Passo 2: CA e trust anchor

6.1 CA

6.2 Trust anchor

7. Passo 3: Role com trust policy restrita

8. Passo 4: Profile do Roles Anywhere

9. Passo 5: Emitir o certificado do usuário

10. Passo 6: Configurar a máquina do usuário (Windows)

10.1 Signing helper

10.2 Manter as credenciais renovadas no credentials

10.3 DSN ODBC

11. Passo 7: Rastrear quem consultou o quê

12. Passo 8: Encerrar o acesso

13. Troubleshooting

14. Referências

ALB com mTLS e CA própria: expondo um serviço interno só para parceiros com certificado

1. Objetivo

2. Conceitos

2.1 Passthrough vs verify

2.2 O que o ALB manda para o backend em modo verify

2.3 Desenho

3. Pré-requisitos

4. Passo 1: Criar a CA

5. Passo 2: Emitir um certificado por parceiro

6. Passo 3: Trust store

7. Passo 4: Target group

8. Passo 5: ALB e listener com mTLS

9. Passo 6: Isolar um parceiro do outro

10. Passo 7: Lado do parceiro (GitHub Actions)

11. Passo 8: Logs de conexão

12. Passo 9: Testar

13. Passo 10: Revogar um parceiro

14. Troubleshooting

15. Referências

CDC do SQL Server para o Amazon MSK com Debezium no MSK Connect: IAM, Secrets Manager e alerta de conexão

1. Objetivo

2. Arquitetura

3. Pré-requisitos

4. Passo 1: Habilitar CDC no SQL Server

4.1 Habilitar no banco

4.2 Habilitar por tabela

4.3 Usuário do Debezium

5. Passo 2: Secret do banco

6. Passo 3: Montar o custom plugin

7. Passo 4: Role de execução do conector

8. Passo 5: Security groups

9. Passo 6: Worker configuration

10. Passo 7: Criar o conector

11. Passo 8: Validar

12. Passo 9: Alerta de erro de conexão com o banco

12.1 Lambda

12.2 Subscription filter

12.3 Testar sem derrubar o banco

13. Troubleshooting

14. Referências

10.2 Manter as credenciais renovadas no `credentials`

2.2 Por que não dá para subir um `.pfx` qualquer

2. Criar usuário `sftp_user`