Bucky

Un outil d'énumération d'ID de compte S3 et de découverte de buckets

Étant donné un seul bucket S3 accessible, bucky extrait l'ID de compte AWS à 12 chiffres qui le possède, puis découvre d'autres buckets appartenant au même compte en testant des noms de bucket à partir d'une wordlist — le tout en une seule commande.

Ce qu'il fait

1. Énumère l'ID de compte — Utilise la clé de condition IAM s3:ResourceAccount pour forcer brutalement l'ID de compte AWS à 12 chiffres, un chiffre à la fois, via des politiques de session STS inline
2. Découvre plus de buckets — Teste des noms de bucket à partir d'une wordlist pour trouver d'autres buckets appartenant au même compte en utilisant des workers concurrents
3. Rapporte tout — ID de compte, région du bucket et tous les buckets découverts

Pourquoi c'est important

Les noms de bucket S3 partageaient à l'origine un espace de noms global unique, ce qui a donné naissance au bucketsquatting — des attaquants pouvaient squatter des noms qu'ils s'attendaient à ce que des organisations créent. AWS a résolu ce problème en déployant des espaces de noms régionaux par compte, un schéma de nommage qui lie chaque bucket à son compte et sa région propriétaires :

{nom}-{IDcompte}-{région}-an

Un bucket nommé myapp-123456789123-eu-north-1-an se trouverait à l'adresse https://myapp-123456789123-eu-north-1-an.s3.eu-north-1.amazonaws.com. AWS recommande désormais ce format pour les nouveaux buckets, bien qu'il ne soit pas encore le format par défaut. (Pour en savoir plus sur la façon dont le nouvel espace de noms élimine le bucketsquatting, consultez One Cloud Please.)

La contrepartie est que l'ID de compte et la région sont désormais intégrés dans le nom du bucket lui-même. Une fois qu'un attaquant obtient l'ID de compte d'une cible, il peut le combiner avec une wordlist et construire systématiquement des URL de bucket valides — et S3 confirmera si chacune existe, même si le bucket est privé. Cette seule réponse constitue une reconnaissance utile.

Bucky exploite exactement cela. S'appuyant sur des recherches de Pwned Labs, il récupère d'abord l'ID de compte à 12 chiffres à partir de n'importe quel bucket accessible en utilisant la technique s3-account-search, puis force brutalement le motif {nom}-{IDcompte}-{région}-an pour découvrir l'empreinte S3 plus large de la cible.

Comment la technique fonctionne

1. Vous créez un rôle IAM dans votre propre compte AWS qui a les droits s3:ListBucket ou s3:GetObject sur le bucket cible
2. Vous appelez sts:AssumeRole sur ce rôle, en passant une politique de session inline avec une condition s3:ResourceAccount comme "1*"
3. Si le compte propriétaire du bucket cible commence par 1, l'appel HeadBucket réussit ; sinon, il retourne une erreur 403
4. Répétez pour chaque position de chiffre (0–9) jusqu'à ce que les 12 chiffres soient découverts
5. La politique de session inline agit comme une limite de permissions — elle intersecte avec les permissions du rôle, donc l'accès n'est accordé que lorsque la condition correspond

Cela nécessite au maximum 120 appels API (12 positions × 10 chiffres) et se termine généralement en moins d'une minute.

Installation

Avec go install

go install github.com/umair9747/bucky@latest

Depuis les sources

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

Mise à jour

bucky --update

Cela télécharge et installe la dernière version depuis le dépôt.

Prérequis : Configuration du rôle IAM

Avant d'utiliser bucky, vous avez besoin d'un rôle IAM dans votre propre compte AWS qui peut accéder au bucket S3 cible. Le bucket cible doit être accessible publiquement ou avoir une politique de bucket qui permet l'accès depuis votre compte.

Étape 1 : Créer la politique de confiance

Créez trust-policy.json — cela permet à votre utilisateur IAM d'assumer le rôle :

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

Remplacez <VOTRE_ID_COMPTE> par votre ID de compte AWS à 12 chiffres. Vous pouvez limiter le principal à un utilisateur IAM ou à un ARN de rôle spécifique au lieu de :root.

Étape 2 : Créer la politique de permissions

Créez s3-policy.json — le rôle nécessite un accès large en lecture S3 (la condition s3:ResourceAccount dans la politique de session inline de bucky gère le filtrage au niveau du compte) :

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

Étape 3 : Créer le rôle

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

Étape 4 : Obtenir l'ARN du rôle

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

Étape 5 : S'assurer de la permission AssumeRole

Si votre utilisateur IAM n'a pas déjà la permission sts:AssumeRole, ajoutez-la :

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

Utilisation

Workflow complet (par défaut)

La principale façon d'utiliser bucky — énumérer l'ID de compte à partir d'un bucket connu, puis tester pour trouver plus de buckets en une seule commande :

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

Avec une clé d'objet connue (améliore la fiabilité) :

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

Plusieurs buckets (séparés par des virgules) :

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

Plusieurs buckets depuis un fichier :

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

Sauvegarder les résultats au format JSON :

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

Sortie :

=== Phase 1 : Énumération de l'ID de compte ===
[*] Vérification de l'accès au bucket : target-bucket
[+] Accès confirmé
[+] Région du bucket : us-west-2
[*] Énumération de l'ID de compte...
  [██████████████████████████████] 12/12 | 675351422352

[+] ID de compte : 675351422352

=== Phase 2 : Découverte de buckets ===
[*] Test des buckets pour le compte : 675351422352
[*] 312 candidats chargés depuis la wordlist
[+] TROUVÉ : target-backups
[+] TROUVÉ : target-logs
  [██████████████████████████████] 312/312 | 2 trouvés

=== Résumé ===
ID de compte : 675351422352
Source       : target-bucket
Région       : us-west-2
Découverts   : 2 bucket(s) supplémentaire(s)
             - target-backups
             - target-logs

Énumération uniquement

Si vous avez seulement besoin de l'ID de compte :

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

Les buckets multiples et la sortie JSON fonctionnent aussi avec les sous-commandes :

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

Test uniquement

Si vous avez déjà un ID de compte et souhaitez découvrir des buckets :

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

Variables d'environnement

Tous les drapeaux peuvent être définis via des variables d'environnement. Les drapeaux ont la priorité lorsque les deux sont définis.

Exemple avec des variables d'environnement

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

# Maintenant, spécifiez simplement la cible
bucky --bucket target-bucket --wordlist wordlists/default.txt

Wordlists

Bucky est livré avec une wordlist par défaut dans wordlists/default.txt contenant environ 300 motifs de nommage courants pour les buckets S3 :

• Noms génériques (backups, logs, data, assets, uploads)
• Motifs de services AWS (cloudtrail-logs, terraform-state, lambda-artifacts)
• Variantes d'environnement (prod-logs, staging-data, dev-backups)
• Motifs d'application (api, web-assets, cdn-origin)
• Infrastructure (ci-artifacts, , )

Wordlists personnalisées

Pour des interventions ciblées, générez une wordlist personnalisée en préfixant le nom de l'organisation :

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

Toute wordlist compatible avec des outils comme ffuf ou gobuster fonctionne. Format : un nom de bucket par ligne, les commentaires # et les lignes vides sont ignorés.

Référence des commandes

Drapeaux

Drapeaux globaux (toutes les commandes) :

bucky (workflow complet) :

bucky enum :

bucky fuzz :

Formats d'entrée des buckets

Les drapeaux --bucket et --bucket-file acceptent plusieurs formats d'entrée. Bucky extrait automatiquement le nom du bucket (et la clé optionnelle) à partir de :

Plusieurs buckets peuvent être passés séparés par des virgules via --bucket :

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

Ou listés un par ligne dans un fichier via --bucket-file :

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

Lorsque plusieurs buckets correspondent au même ID de compte, bucky déduplique et n'exécute le test qu'une seule fois par compte unique.

Sortie JSON

Utilisez --json pour sauvegarder les résultats dans un fichier JSON. Le nom de fichier par défaut est bucky-{uuid}.json dans le répertoire courant, ou vous pouvez spécifier un chemin avec --output :

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

Format de sortie :

{
  "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"
      ]
    }
  ]
}

Gestion de la région des buckets

Bucky détecte automatiquement la région des buckets cibles. Lorsque S3 retourne une redirection 301 (le bucket se trouve dans une région différente de --region), bucky résout la région correcte via l'en-tête de réponse HTTP x-amz-bucket-region et la met en cache pour toutes les requêtes suivantes. Aucune configuration manuelle de région n'est nécessaire pour le bucket cible.

Restons en contact !

Si vous avez des questions ou des retours sur Genzai ou si vous souhaitez simplement me contacter, n'hésitez pas à me joindre via LinkedIn ou par Email.