Bucky

Una herramienta de enumeración de ID de cuenta S3 y descubrimiento de buckets

Dado un único bucket S3 accesible, bucky extrae el ID de cuenta AWS de 12 dígitos que lo posee, luego descubre buckets adicionales pertenecientes a la misma cuenta probando nombres de buckets contra una lista de palabras — todo en un solo comando.

Lo que hace

1. Enumera el ID de cuenta — Usa la clave de condición IAM s3:ResourceAccount para forzar bruto el ID de cuenta AWS de 12 dígitos un dígito a la vez mediante políticas de sesión STS en línea
2. Descubre más buckets — Prueba nombres de buckets desde una lista de palabras para encontrar buckets adicionales propiedad de la misma cuenta utilizando workers concurrentes
3. Reporta todo — ID de cuenta, región del bucket y todos los buckets descubiertos

Por qué esto importa

Originalmente, los nombres de los buckets S3 compartían un único espacio de nombres global, lo que dio lugar al bucketsquatting — los atacantes podían apropiarse de nombres que esperaban que las organizaciones crearan. AWS abordó esto implementando espacios de nombres regionales por cuenta, un esquema de nombres que vincula cada bucket a su cuenta y región propietarias:

{nombre}-{IDcuenta}-{región}-an

Un bucket llamado myapp-123456789123-eu-north-1-an residiría en https://myapp-123456789123-eu-north-1-an.s3.eu-north-1.amazonaws.com. AWS ahora recomienda este formato para buckets nuevos, aunque aún no es el predeterminado. (Para conocer los antecedentes de cómo el nuevo espacio de nombres elimina el bucketsquatting, consulte One Cloud Please.)

La contrapartida es que el ID de cuenta y la región ahora están incorporados en el nombre del bucket. Una vez que un atacante obtiene el ID de cuenta de un objetivo, puede combinarlo con una lista de palabras y construir sistemáticamente URLs de buckets válidas — y S3 confirmará si cada una existe, incluso si el bucket es privado. Esa respuesta por sí sola es una valiosa inteligencia.

Bucky explota precisamente esto. Basándose en la investigación de Pwned Labs, primero recupera el ID de cuenta de 12 dígitos de cualquier bucket accesible utilizando la técnica s3-account-search, luego fuerza bruta el patrón {nombre}-{IDcuenta}-{región}-an para descubrir la huella S3 más amplia del objetivo.

Cómo funciona la técnica

1. Creas un rol IAM en tu propia cuenta AWS que tenga s3:ListBucket o s3:GetObject en el bucket objetivo
2. Llamas a sts:AssumeRole en ese rol, pasando una política de sesión en línea con una condición s3:ResourceAccount como "1*"
3. Si la cuenta propietaria del bucket objetivo comienza con 1, la llamada HeadBucket tiene éxito; de lo contrario, devuelve 403
4. Repites para cada posición de dígito (0–9) hasta que se descubran los 12 dígitos
5. La política de sesión en línea actúa como un límite de permisos: se intersecta con los permisos del rol, por lo que el acceso solo se concede cuando la condición coincide

Esto requiere como máximo 120 llamadas API (12 posiciones × 10 dígitos) y suele completarse en menos de un minuto.

Instalación

Usando go install

go install github.com/umair9747/bucky@latest

Desde el código fuente

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

Actualizando

bucky --update

Esto descarga e instala la última versión del repositorio.

Requisitos previos: Configuración del rol IAM

Antes de usar bucky, necesitas un rol IAM en tu propia cuenta AWS que pueda acceder al bucket S3 objetivo. El bucket objetivo debe ser accesible públicamente o tener una política de bucket que permita el acceso desde tu cuenta.

Paso 1: Crear la política de confianza

Crea trust-policy.json — esto permite que tu usuario IAM asuma el rol:

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

Reemplaza <TU_ID_DE_CUENTA> con tu ID de cuenta AWS de 12 dígitos. Puedes limitar el principal a un usuario IAM específico o ARN de rol en lugar de :root.

Paso 2: Crear la política de permisos

Crea s3-policy.json — el rol necesita permisos de lectura amplios en S3 (la condición s3:ResourceAccount en la política de sesión en línea de bucky maneja el filtrado a nivel de cuenta):

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

Paso 3: Crear el rol

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

Paso 4: Obtener el ARN del rol

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

Paso 5: Asegurar el permiso AssumeRole

Si tu usuario IAM aún no tiene permiso sts:AssumeRole, adjúntalo:

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

Uso

Flujo de trabajo completo (predeterminado)

La forma principal de usar bucky — enumerar el ID de cuenta desde un bucket conocido, luego probar más buckets en un solo paso:

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 clave de objeto conocida (mejora la fiabilidad):

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

Múltiples buckets (separados por comas):

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

Múltiples buckets desde un archivo:

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

Guardar resultados en JSON:

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

Salida:

=== Fase 1: Enumeración de ID de cuenta ===
[*] Verificando acceso al bucket: target-bucket
[+] Acceso confirmado
[+] Región del bucket: us-west-2
[*] Enumerando ID de cuenta...
  [██████████████████████████████] 12/12 | 675351422352

[+] ID de cuenta: 675351422352

=== Fase 2: Descubrimiento de buckets ===
[*] Probando buckets para la cuenta: 675351422352
[*] Cargadas 312 candidatos de la lista de palabras
[+] ENCONTRADO: target-backups
[+] ENCONTRADO: target-logs
  [██████████████████████████████] 312/312 | 2 encontrados

=== Resumen ===
ID de cuenta : 675351422352
Fuente      : target-bucket
Región      : us-west-2
Descubiertos: 2 bucket(s) adicional(es)
             - target-backups
             - target-logs

Solo enumeración

Si solo necesitas el ID de cuenta:

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

Múltiples buckets y salida JSON también funcionan con subcomandos:

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

Solo fuzzing

Si ya tienes un ID de cuenta y deseas descubrir buckets:

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

Variables de entorno

Todos los flags pueden configurarse mediante variables de entorno. Los flags tienen prioridad cuando ambos están establecidos.

Ejemplo con variables de entorno

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

# Ahora solo especifica el objetivo
bucky --bucket target-bucket --wordlist wordlists/default.txt

Listas de palabras

Bucky incluye una lista de palabras predeterminada en wordlists/default.txt con aproximadamente 300 patrones de nombres de buckets S3 comunes:

• Nombres genéricos (backups, logs, data, assets, uploads)
• Patrones de servicios AWS (cloudtrail-logs, terraform-state, lambda-artifacts)
• Variantes de entorno (prod-logs, staging-data, dev-backups)
• Patrones de aplicación (api, web-assets, cdn-origin)
• Infraestructura (ci-artifacts, , )

Listas de palabras personalizadas

Para compromisos dirigidos, genera una lista de palabras personalizada anteponiendo el nombre de la organización:

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

Cualquier lista de palabras compatible con herramientas como ffuf o gobuster funciona. Formato: un nombre de bucket por línea, comentarios con #, líneas en blanco ignoradas.

Referencia de comandos

Flags

Flags globales (todos los comandos):

bucky (flujo de trabajo completo):

bucky enum:

bucky fuzz:

Formatos de entrada de buckets

El flag --bucket y --bucket-file aceptan múltiples formatos de entrada. Bucky extrae automáticamente el nombre del bucket (y la clave opcional) de:

Se pueden pasar múltiples buckets separados por comas mediante --bucket:

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

O listados uno por línea en un archivo mediante --bucket-file:

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

Cuando múltiples buckets resuelven al mismo ID de cuenta, bucky elimina duplicados y ejecuta el fuzzing solo una vez por cuenta única.

Salida JSON

Usa --json para guardar los resultados en un archivo JSON. El nombre de archivo predeterminado es bucky-{uuid}.json en el directorio actual, o especifica una ruta con --output:

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

Formato de salida:

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

Manejo de región de buckets

Bucky detecta automáticamente la región de los buckets objetivo. Cuando S3 devuelve una redirección 301 (el bucket está en una región diferente a --region), bucky resuelve la región correcta mediante el encabezado de respuesta HTTP x-amz-bucket-region y lo almacena en caché para todas las solicitudes posteriores. No se necesita configuración manual de región para el bucket objetivo.

¡Conectémonos!

Si tienes alguna pregunta o comentario sobre Genzai o simplemente quieres contactarte conmigo, no dudes en escribirme a través de LinkedIn o Correo electrónico.