API key leaks

web hacking

Las claves API y los tokens son métodos de autenticación que se utilizan comúnmente para gestionar permisos y acceso a servicios públicos y privados. La filtración de estos datos confidenciales puede provocar accesos no autorizados, comprometer la seguridad y posibles filtraciones de datos.

Claves API: Identificadores únicos que se utilizan para autenticar las solicitudes asociadas a tu proyecto o aplicación.

Tokens: Tokens de seguridad (como los tokens OAuth) que otorgan acceso a recursos protegidos.

Enumeración y Explotación

trufflesecurity sera solo un ejemplo de una "víctima".

Uasaremos la herramienta de truffleHog : https://github.com/trufflesecurity/truffleHog

  • Leak de API key en el código fuente : algunos desarrolladores pueden sin querer dejar API keys o tokens directamente en el código fuente.

# Ejemplo
api_key = "23fg4443334r3"

  • repositorios públicos : Poner accidentalmente datos sensibles a un control publico accesible de sistemas como github

# ejemplos

### escanear una organizacion de github
docker run --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --org=trufflesecurity

### escanear un repositorio de github, sus problemas y pull requests
docker run --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys --issue-comments --pr-comments

  • Harcoding en imagenes de Docker : Api keys y credenciales podrían estar harcodeadas en Docker images hosteadas en Dockerhub o registros privados

# escanear una imagen de docker por secretos verificados
docker run --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest docker --image trufflesecurity/secrets

  • Logs e Informacion de Debug : las keys y los tokens podrían ser representadas durante procesos de debugging y logs

  • Archivos de configuracion : Keys y tokens que estan incluidos accidentalmente en archivos de configuración accesibles como : - archivos .env - archivos .aws - config.json - settings.py - credential files

es recomendable buscar en el código fuente esta información si lo tenemos a mano, podemos revisar el github de la web por ejemplo.

Herramientas

  • Keyfinder es una extensión de Chrome que nos permite buscar en el DOM por cualquier link de script incrustado, que podría contener Keys por una API especifica

https://github.com/momenbasel/KeyFinder.git

ahora para la finalizar la instalación ve a:

	chrome://extensions
	Ahi activa el "Developer mode"
	agarra y dropea ahi el folder de keyfinder

ahora puedes visitar el sitio web del objetivo e ir visitando paginas, la extensión ira automáticamente capturando api keys publicas y ocultas. La extensión te permite agregar tus propios filtros o palabras clave.

Ahora vamos a verificar nuestras llaves API

este texto sirve como una guía para identificar a qué servicio pertenece una API key y cómo verificar si es válida. Está orientado a investigadores de seguridad (como los que participan en programas de bug bounty)

1. Algolia API KEYS

Tenga cuidado al ejecutar este comando, ya que la carga útil podría ejecutarse dentro de un entorno administrativo, dependiendo del índice del que esté editando highlightPreTag. Se recomienda usar una carga útil más silenciosa (como XSS Hunter) para probar el posible ataque de secuencias de comandos entre sitios.

curl --request PUT \  
--url https://<application-id>-1.algolianet.com/1/indexes/<example-index>/settings \  
--header 'content-type: application/json' \  
--header 'x-algolia-api-key: <example-key>' \  
--header 'x-algolia-application-id: <example-application-id>' \  
--data '{"highlightPreTag": "<script>alert(1);</script>"}'

2. AWS Access Key ID & Secret

Instale awscli. Establezca la clave de acceso y el secreto en las variables de entorno y ejecute el siguiente comando.

AWS_ACCESS_KEY_ID=xxxx AWS_SECRET_ACCESS_KEY=yyyy aws sts get-caller-identity

Los permisos de las credenciales de AWS se pueden determinar usando Enumerate-IAM. Esto proporciona una visión más amplia de los privilegios de las credenciales de AWS descubiertos en lugar de solo verificar los depósitos S3.

git clone https://github.com/andresriancho/enumerate-iam
cd enumerate-iam  
./enumerate-iam.py — access-key AKIA… — secret-key StF0q…

3. Slack API token

curl -sX POST “https://slack.com/api/auth.test?token=xoxp-TOKEN_HERE&pretty=1

4. Facebook Access Token

https://developers.facebook.com/tools/debug/accesstoken/?access_token=ACCESS_TOKEN_HERE&version=v3.2

5. Github client id and client secret

curl ‘https://api.github.com/users/whatever?client_id=xxxx&client_secret=yyyy'

6. Twilio Account_sid and Auth token

curl -X GET ‘https://api.twilio.com/2010-04-01/Accounts.json' -u ACCOUNT_SID:AUTH_TOKEN

7. Twitter API Secret

curl -u ‘API key:API secret key’ — data ‘grant_type=client_credentials’ ‘https://api.twitter.com/oauth2/token'

8. Twitter Bearer token

curl — request GET — url https://api.twitter.com/1.1/account_activity/all/subscriptions/count.json — header ‘authorization: Bearer TOKEN’

9. SendGrid API Token

curl -X “GET” “https://api.sendgrid.com/v3/scopes" -H “Authorization: Bearer SENDGRID_TOKEN-HERE” -H “Content-Type: application/json”

10. MailGun Private Key

curl — user ‘api:key-PRIVATEKEYHERE’ “https://api.mailgun.net/v3/domains"

11. Heroku API key

curl -X POST https://api.heroku.com/apps -H “Accept: application/vnd.heroku+json; version=3” -H “Authorization: Bearer API_KEY_HERE”

12. Mapbox API key

Mapbox secret keys start with sk, rest start with pk (public token), sk (secret token), or tk (temporary token).

curl “https://api.mapbox.com/geocoding/v5/mapbox.places/Los%20Angeles.json?access_token=ACCESS_TOKEN"

13. Zendesk Access token

curl https://{subdomain}.zendesk.com/api/v2/tickets.json \ -H “Authorization: Bearer ACCESS_TOKEN”

14. Travis CI API token

curl -H “Travis-API-Version: 3” -H “Authorization: token <TOKEN>” https://api.travis-ci.com/user

15. Gitlab personal access token

curl “https://gitlab.example.com/api/v4/projects?private_token=<your_access_token>"

  • aqui podemos encontrar mas : https://github.com/streaak/keyhacks?source=post_page-----11b1e5d0f01d----------------------

Que se puede hacer realmente con esa clave?

  • “Con una clave de AWS puedes listar buckets, lanzar instancias EC2, etc.”

  • “Con una clave de SendGrid puedes mandar emails desde el dominio de la empresa → phishing.”

  • “Con una API key de Mapbox mal configurada, alguien puede usar el servicio y hacer que pagues miles en facturación.”

y mucho mas, depende de cada clave y servicio, pero no siempre sera como eso, toma en cuenta estos errores (y te vas a ahorrar horas) :

  • “Tengo una API key, eso ya es crítico” ❌ (muchas son de solo lectura o tienen permisos limitados).

  • “La clave es válida, entonces puedo explotarla” ❌ (puede estar ligada a una IP, dominio o limitarse a un endpoint sin riesgo).

Siempre que encuentres una clave:

  • Verifica los permisos (lectura, escritura, admin…).

  • Verifica el contexto: ¿web pública? ¿app interna? ¿backend?

  • Haz acciones controladas y registradas si estás en bug bounty (para no romper nada).

Cómo identificar el contexto:

¿Dónde fue encontrada la clave?

  • En el frontend (JS minificado): probablemente pública, limitada.

  • En un .env privado: probablemente backend o clave sensible.

  • En logs: puede estar usada en producción o staging.

¿Está ligada a una IP, dominio o app?

  • Algunas claves están restringidas por IP (Google Cloud, Firebase).

  • Otras, por referer (Mapbox, Algolia).

Prueba mandando peticiones desde un entorno distinto (tu máquina o Burp) y fíjate si te da:

{ "message": "invalid referer" }

¿Es una clave "test" o "live"?

Muchos servicios lo indican directamente:

  • Stripe: sk_test_ o sk_live_

  • Algolia: claves de test a veces solo permiten una búsqueda sencilla

  • Firebase: claves públicas suelen tener reglas de seguridad activadas

🛠 Tips útiles para verificar contexto:

  • Revisa documentación oficial del servicio → te dirá qué endpoints puedes probar, y cómo ver el scope o permisos.

  • Usa Burp Suite o Postman para experimentar rápidamente con headers personalizados.

  • En bug bounty, busca endpoints de la web objetivo que usen esa API key, para ver cómo la usan ellos.

script de prueba rápida

#!/bin/bash TOKEN="$1" echo "[+] Probando validez..." curl -s -H "Authorization: token $TOKEN" https://api.github.com/user | jq . echo "[+] Probando acceso a repos..." curl -s -H "Authorization: token $TOKEN" https://api.github.com/user/repos | jq .

Es funcional, aunque podrías expandirlo un poco con mas servicios o detección automática del tipo de token.

some explotation references from here

PreviousPrompt injections / ingenieria de promptsNextWeb Cache Deception

Last updated