Bucky

Uno strumento per l'enumerazione degli ID account S3 e la scoperta di bucket

Dato un singolo bucket S3 accessibile, bucky estrae l'ID account AWS di 12 cifre che lo possiede, poi scopre bucket aggiuntivi appartenenti allo stesso account fuzzando i nomi dei bucket contro una wordlist — tutto in un unico comando.

Cosa Fa

1. Enumera l'ID account — Utilizza la chiave di condizione IAM s3:ResourceAccount per forzare l'ID account AWS di 12 cifre una cifra alla volta attraverso policy di sessione STS inline
2. Scopre più bucket — Fuzza i nomi dei bucket da una wordlist per trovare bucket aggiuntivi posseduti dallo stesso account usando worker concorrenti
3. Riporta tutto — ID account, regione del bucket e tutti i bucket scoperti

Perché è Importante

I nomi dei bucket S3 originariamente condividevano un unico namespace globale, il che ha dato origine al bucketsquatting — gli attaccanti potevano accaparrarsi nomi che si aspettavano che le organizzazioni creassero. AWS ha risolto questo problema implementando namespace account-regionali, uno schema di denominazione che lega ogni bucket al suo account e regione proprietari:

{nome}-{accountID}-{regione}-an

Un bucket chiamato myapp-123456789123-eu-north-1-an si troverebbe all'indirizzo https://myapp-123456789123-eu-north-1-an.s3.eu-north-1.amazonaws.com. AWS ora raccomanda questo formato per i nuovi bucket, anche se non è ancora il default. (Per approfondimenti su come il nuovo namespace elimina il bucketsquatting, vedi One Cloud Please.)

Il compromesso è che l'ID account e la regione sono ora incorporati nel nome del bucket stesso. Una volta che un attaccante ottiene l'ID account di un target, può abbinarlo a una wordlist e costruire sistematicamente URL di bucket validi — e S3 confermerà se ciascuno esiste, anche se il bucket è privato. Quella risposta da sola è una ricognizione utile.

Bucky sfrutta proprio questo. Basandosi sulla ricerca di Pwned Labs, recupera prima l'ID account di 12 cifre da qualsiasi bucket accessibile utilizzando la tecnica s3-account-search, poi forza bruta il pattern {nome}-{accountID}-{regione}-an per scoprire la più ampia impronta S3 del target.

Come Funziona la Tecnica

1. Crei un ruolo IAM nel tuo account AWS che ha s3:ListBucket o s3:GetObject sul bucket target
2. Chiami sts:AssumeRole su quel ruolo, passando una policy di sessione inline con una condizione s3:ResourceAccount come "1*"
3. Se l'account proprietario del bucket target inizia con 1, la chiamata HeadBucket ha successo; altrimenti restituisce 403
4. Ripeti per ogni posizione della cifra (0–9) finché tutte le 12 cifre non vengono scoperte
5. La policy di sessione inline funge da limite di autorizzazione — si interseca con le autorizzazioni del ruolo, quindi l'accesso è concesso solo quando la condizione corrisponde

Questo richiede al massimo 120 chiamate API (12 posizioni × 10 cifre) e tipicamente si completa in meno di un minuto.

Installazione

Usando go install

go install github.com/umair9747/bucky@latest

Dal Codice Sorgente

git clone https://github.com/umair9747/bucky.git
cd bucky
go build -o bucky .
sudo mv bucky /usr/local/bin/

Aggiornamento

bucky --update

Questo recupera e installa l'ultima versione dal repository.

Prerequisiti: Configurazione del Ruolo IAM

Prima di usare bucky, hai bisogno di un ruolo IAM nel tuo account AWS che possa accedere al bucket S3 target. Il bucket target deve essere pubblicamente accessibile o avere una policy del bucket che consenta l'accesso dal tuo account.

Passo 1: Crea la Trust Policy

Crea trust-policy.json — questo permette al tuo utente IAM di assumere il ruolo:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::<TUO_ACCOUNT_ID>:root"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

Sostituisci <TUO_ACCOUNT_ID> con il tuo ID account AWS di 12 cifre. Puoi restringere il principal a uno specifico ARN di utente o ruolo IAM invece di :root.

Passo 2: Crea la Permissions Policy

Crea s3-policy.json — il ruolo necessita di accesso in lettura S3 ampio (la condizione s3:ResourceAccount nella policy di sessione inline di bucky gestisce il filtraggio a livello di account):

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:ListBucket",
        "s3:GetObject"
      ],
      "Resource": "*"
    }
  ]
}

Passo 3: Crea il Ruolo

aws iam create-role \
  --role-name bucky-role \
  --assume-role-policy-document file://trust-policy.json

aws iam put-role-policy \
  --role-name bucky-role \
  --policy-name S3ReadAccess \
  --policy-document file://s3-policy.json

Passo 4: Ottieni l'ARN del Ruolo

aws iam get-role --role-name bucky-role --query 'Role.Arn' --output text
# Output: arn:aws:iam::123456789012:role/bucky-role

Passo 5: Assicurati dell'Autorizzazione AssumeRole

Se il tuo utente IAM non ha già l'autorizzazione sts:AssumeRole, allegala:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "sts:AssumeRole",
      "Resource": "arn:aws:iam::<TUO_ACCOUNT_ID>:role/bucky-role"
    }
  ]
}

Utilizzo

Flusso di Lavoro Completo (Predefinito)

Il modo principale di usare bucky — enumera l'ID account da un bucket noto, poi fuzza per più bucket in un colpo solo:

bucky \
  --role-arn arn:aws:iam::123456789012:role/bucky-role \
  --bucket target-bucket \
  --wordlist wordlists/default.txt \
  --access-key AKIA... \
  --secret-key wJal...

Con una chiave oggetto nota (migliora l'affidabilità):

bucky \
  --role-arn arn:aws:iam::123456789012:role/bucky-role \
  --bucket s3://target-bucket/index.html \
  --wordlist wordlists/default.txt \
  --workers 20

Più bucket (separati da virgola):

bucky \
  --role-arn arn:aws:iam::123456789012:role/bucky-role \
  --bucket bucket1,bucket2,bucket3 \
  --wordlist wordlists/default.txt

Più bucket da un file:

bucky \
  --role-arn arn:aws:iam::123456789012:role/bucky-role \
  --bucket-file targets.txt \
  --wordlist wordlists/default.txt

Salva i risultati in JSON:

bucky --bucket target-bucket --wordlist wordlists/default.txt --json
bucky --bucket target-bucket --wordlist wordlists/default.txt --json --output results.json

Output:

=== Fase 1: Enumerazione ID Account ===
[*] Verifica accesso al bucket: target-bucket
[+] Accesso confermato
[+] Regione bucket: us-west-2
[*] Enumerazione ID account...
  [██████████████████████████████] 12/12 | 675351422352

[+] ID Account: 675351422352

=== Fase 2: Scoperta Bucket ===
[*] Fuzzing bucket per account: 675351422352
[*] Caricati 312 candidati dalla wordlist
[+] TROVATO: target-backups
[+] TROVATO: target-logs
  [██████████████████████████████] 312/312 | 2 trovati

=== Riepilogo ===
ID Account : 675351422352
Sorgente   : target-bucket
Regione    : us-west-2
Scoperti   : 2 bucket aggiuntivi
             - target-backups
             - target-logs

Solo Enumerazione

Se hai solo bisogno dell'ID account:

bucky enum \
  --role-arn arn:aws:iam::123456789012:role/bucky-role \
  --bucket target-bucket

Più bucket e output JSON funzionano anche con i sottocomandi:

bucky enum --bucket bucket1,bucket2 --json
bucky enum --bucket-file targets.txt --json --output results.json

Solo Fuzzing

Se hai già un ID account e vuoi scoprire bucket:

bucky fuzz \
  --role-arn arn:aws:iam::123456789012:role/bucky-role \
  --account-id 675351422352 \
  --wordlist wordlists/default.txt \
  --workers 20

Variabili d'Ambiente

Tutti i flag possono essere impostati tramite variabili d'ambiente. I flag hanno la precedenza quando entrambi sono impostati.

Esempio con Variabili d'Ambiente

export AWS_ACCESS_KEY_ID=AKIA...
export AWS_SECRET_ACCESS_KEY=wJal...
export BUCKY_ROLE_ARN=arn:aws:iam::123456789012:role/bucky-role

# Ora specifica solo il target
bucky --bucket target-bucket --wordlist wordlists/default.txt

Wordlist

Bucky è fornito con una wordlist predefinita in wordlists/default.txt contenente circa 300 pattern comuni di denominazione di bucket S3:

• Nomi generici (backups, logs, data, assets, uploads)
• Pattern dei servizi AWS (cloudtrail-logs, terraform-state, lambda-artifacts)
• Varianti di ambiente (prod-logs, staging-data, dev-backups)
• Pattern applicativi (api, web-assets, cdn-origin)
• Infrastruttura (ci-artifacts, , )

Wordlist Personalizzate

Per engagement mirati, genera una wordlist personalizzata aggiungendo il nome dell'organizzazione:

ORG="acme"
while read -r line; do
  [[ "$line" =~ ^#.*$ || -z "$line" ]] && continue
  echo "${ORG}-${line}"
  echo "${line}-${ORG}"
  echo "${ORG}${line}"
done < wordlists/default.txt > wordlists/acme.txt

Qualsiasi wordlist compatibile con strumenti come ffuf o gobuster funziona. Formato: un nome bucket per riga, commenti #, righe vuote ignorate.

Riferimento Comandi

Flag

Flag globali (tutti i comandi):

bucky (flusso di lavoro completo):

bucky enum:

bucky fuzz:

Formati di Input dei Bucket

Il flag --bucket e --bucket-file accettano più formati di input. Bucky estrae automaticamente il nome del bucket (e la chiave opzionale) da:

Più bucket possono essere passati separati da virgola tramite --bucket:

--bucket bucket1,s3://bucket2/key,https://bucket3.s3.amazonaws.com/

Oppure elencati uno per riga in un file tramite --bucket-file:

my-bucket
s3://another-bucket/index.html
https://third.s3.us-east-1.amazonaws.com/

Quando più bucket risolvono allo stesso ID account, bucky deduplica ed esegue il fuzzing solo una volta per account univoco.

Output JSON

Usa --json per salvare i risultati in un file JSON. Il nome file predefinito è bucky-{uuid}.json nella directory corrente, oppure specifica un percorso con --output:

bucky --bucket target-bucket --wordlist wordlists/default.txt --json
bucky --bucket target-bucket --wordlist wordlists/default.txt --json --output results.json

Formato di output:

{
  "timestamp": "2024-01-15T10:30:00Z",
  "results": [
    {
      "bucket": "target-bucket",
      "account_id": "675351422352",
      "region": "ap-south-1",
      "discovered_buckets": [
        "dev-675351422352-ap-south-1-an.s3.ap-south-1.amazonaws.com",
        "prod-675351422352-ap-south-1-an.s3.ap-south-1.amazonaws.com"
      ]
    }
  ]
}

Gestione della Regione dei Bucket

Bucky rileva automaticamente la regione dei bucket target. Quando S3 restituisce un reindirizzamento 301 (il bucket si trova in una regione diversa da --region), bucky risolve la regione corretta tramite l'intestazione della risposta HTTP x-amz-bucket-region e la memorizza nella cache per tutte le richieste successive. Non è necessaria alcuna configurazione manuale della regione per il bucket target.

Restiamo in Contatto!

Se hai domande o feedback su Genzai o semplicemente vuoi entrare in contatto con me, non esitare a contattarmi tramite LinkedIn o Email.