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

É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
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
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

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
Vous appelez sts:AssumeRole sur ce rôle, en passant une politique de session inline avec une condition s3:ResourceAccount comme "1*"
Si le compte propriétaire du bucket cible commence par 1, l'appel HeadBucket réussit ; sinon, il retourne une erreur 403
Répétez pour chaque position de chiffre (0–9) jusqu'à ce que les 12 chiffres soient découverts
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

bucky

Populaires