Análisis JavaScript client-side — endpoints, secrets y source maps

Respuesta rápida

El JS client-side de cualquier SPA moderna esconde endpoints internos, API keys, lógica de autorización y rutas no documentadas. La metodología: recolectar todos los .js con getJS → extraer endpoints con LinkFinder → detectar secrets con trufflehog → buscar .map files (source maps en producción son un fail común) → reconstruir el source completo. Bounty típico de un secret expuesto en JS: €500-€3000.

Static analysis

Gather JS files

cat alive.txt | getJS -complete | sort -u > js_urls.txt

# Download all JS files
cat js_urls.txt | while read url; do
  wget -q "$url" -P ./js_files/
done

# Bonus: Wayback Machine — versiones antiguas con endpoints deprecated
waybackurls target.com | grep "\.js$" | sort -u >> js_urls.txt

Identify endpoints with LinkFinder

python3 LinkFinder.py -i https://target.com/main.js -o cli

# Batch mode
cat js_urls.txt | while read url; do
  python3 LinkFinder.py -i "$url" -o cli
done 2>/dev/null | sort -u > endpoints.txt

LinkFinder usa regex para detectar strings con shape de URL en el código. Muchas veces revela endpoints internos /api/admin/*, /internal/* que nunca aparecen en docs.

Detect secrets with TruffleHog

trufflehog filesystem ./js_files/ --only-verified

cat js_urls.txt | while read url; do
  curl -s "$url" | trufflehog --regex --entropy=False
done

--only-verified evita falsos positivos: trufflehog hace una petición a la API real (GitHub, AWS) para confirmar que la key sigue activa.

Patrones grep manuales

A veces más rápido que las tools:

Source maps — el fail favorito

Cuando un build de producción incluye .map files, el código fuente original (sin minify) está accesible. Vercel, Netlify y muchos CI/CD pipelines los suben por defecto a menos que el dev los excluya explícitamente.

# Check si existe el map
curl -s -o /dev/null -w "%{http_code}" https://target.com/main.js.map

Reconstruir source

npx source-map-explorer main.js main.js.map
# O en Chrome DevTools: Sources tab → si el .map se carga, ves directorios originales src/

[!warning] Impacto Source maps revelan: estructura de carpetas, nombres de archivos internos, comentarios del autor, lógica de feature flags, endpoints de admin no documentados. Severidad media-alta.

Dynamic analysis

Function monitoring

Inyecta en console del browser para interceptar cualquier llamada fetch o XMLHttpRequest:

const originalFetch = window.fetch;
window.fetch = function() {
    console.log('Fetch called:', arguments);
    return originalFetch.apply(this, arguments);
};

const originalOpen = XMLHttpRequest.prototype.open;
XMLHttpRequest.prototype.open = function() {
    console.log('XHR called:', arguments);
    return originalOpen.apply(this, arguments);
};

Útil para mapear qué endpoints invoca cada acción del UI sin tocar Burp.

Breakpoints estratégicos

En DevTools → Sources tab:

• XHR/Fetch breakpoints: pausa cuando se invoca un patrón de URL específico.
• Event listener breakpoints: submit, click — útil para auth flows.
• DOM breakpoints: subtree modifications en elementos sensibles (p.ej. <input> de password).
• Conditional breakpoints: solo pausan si una variable tiene cierto valor.

React Native — Android bundles

Las apps React Native distribuyen el JS como index.android.bundle empaquetado en el .apk. Suele contener endpoints staging, Firebase configs y API keys hardcoded.

# Extract bundle
unzip app.apk -d extracted/
find extracted/ -name "index.android.bundle"

# Source map check
grep -rnis 'sourceMappingURL' index.android.bundle
# Si se referencia un .map → puede estar en producción → source completo

# Buscar secrets
grep -rnis 'apiKey\|FIREBASE_API_KEY\|FIREBASE_AUTH_DOMAIN\|secret\|token\|password' \
  index.android.bundle

Frida — dynamic instrumentation

Para hookear métodos Java o nativos en runtime sin recompilar la app.

Setup Android

adb push frida-server-*-android-x86_64 /data/local/tmp/frida-server
adb shell chmod +x /data/local/tmp/frida-server
adb shell /data/local/tmp/frida-server &

Override de método Java

Java.perform(function () {
  var MainActivity = Java.use("com.example.app.MainActivity");

  MainActivity.check.implementation = function (input) {
    return true; // Bypass validation
  };
});

SSL pinning bypass

frida -U -f com.example.app -l ssl-pinning-bypass.js

Permite interceptar el tráfico HTTPS de la app en Burp/mitmproxy.

Hunting checklist

• getJS -complete en todos los hosts alive
• Wayback machine para .js históricos
• LinkFinder en cada .js → endpoints internos
• trufflehog con --only-verified para secrets activos
• Grep manual de patrones AWS/Firebase/API keys
• Check de .map files en producción → si existen, source completo
• React Native: extract index.android.bundle, grep secrets
• DevTools Sources: XHR breakpoints en flows críticos
• Frida si la app es mobile y quieres bypassear lógica client-side

Labs relacionados

Practica análisis JS client-side y caza de secrets en bundles con labs de Recon y JavaScript Analysis.