# En Kali Linux ya viene instalado — lanzar directamente
burpsuite
# O desde el menú: Applications → Web Application Analysis → burpsuite

# Si no está instalado o quieres la última versión
sudo apt update && sudo apt install burpsuite -y

# Verificar versión
burpsuite --version

# Descargar desde portswigger.net/burp/communitydownload
# Descargar el instalador .sh para Linux
wget "https://portswigger.net/burp/releases/download?product=community&type=Linux" \
  -O burpsuite_community_linux.sh
chmod +x burpsuite_community_linux.sh
./burpsuite_community_linux.sh
# Seguir el asistente gráfico de instalación

## WINDOWS
# 1. Ir a: portswigger.net/burp/communitydownload
# 2. Descargar el instalador .exe para Windows
# 3. Ejecutar el .exe como administrador y seguir el asistente
# 4. Burp Suite aparecerá en el menú Inicio

## macOS
# Opción 1 — Instalador .dmg desde la web de PortSwigger
# Opción 2 — Homebrew
brew install --cask burp-suite

## JAVA (si falla el lanzamiento)
# Burp requiere Java 17+. Si no arranca:
java -version   # verificar versión
sudo apt install openjdk-21-jre -y   # instalar en Debian/Ubuntu

# Chrome / Chromium con proxy de Burp
google-chrome --proxy-server="http://127.0.0.1:8080" --ignore-certificate-errors
chromium-browser --proxy-server="http://127.0.0.1:8080"

# Firefox desde terminal
firefox --proxy-server="127.0.0.1:8080"

# Alternativa: usar FoxyProxy (extensión del navegador)
# Permite cambiar el proxy con un clic sin tocar la configuración del sistema

# Juice Shop — el más completo
docker run --rm -p 3000:3000 bkimminich/juice-shop
# Acceder en: http://localhost:3000

# DVWA — clásico para SQLi y XSS básico
docker run --rm -p 80:80 vulnerables/web-dvwa
# Acceder en: http://localhost
# Login: admin / password
# Ir a Setup/Reset DB → luego DVWA Security → Low

# WebGoat — lecciones guiadas
docker run --rm -p 8081:8080 -p 9090:9090 webgoat/webgoat
# Acceder en: http://localhost:8081/WebGoat

# Con docker-compose para tener todo a la vez
cat > docker-compose.yml << 'EOF'
version: "3"
services:
  juiceshop:
    image: bkimminich/juice-shop
    ports: ["3000:3000"]
  dvwa:
    image: vulnerables/web-dvwa
    ports: ["8082:80"]
  webgoat:
    image: webgoat/webgoat
    ports: ["8083:8080"]
EOF
docker-compose up -d

# Cómo configurar el scope en Burp:
1. Target → Scope Settings → Include in scope
2. Add → Host: localhost  Port: 3000
3. En Proxy Settings → marcar "And URL is in target scope"
   → Burp solo capturará tráfico hacia localhost:3000

Alternativa rápida:
- En HTTP History, clic derecho en cualquier petición
  → "Add to scope"
  → Burp pregunta si quieres ignorar el tráfico fuera del scope

# Verificar el scope activo
Target → Site Map → muestra solo los hosts en el scope

# Burp Suite incluye listas en: Help → Burp Suite Defaults → Payload Lists
# También disponibles en SecLists (la colección más completa)

git clone https://github.com/danielmiessler/SecLists.git

# Las más útiles para Intruder en tests de aplicaciones web:
SecLists/Discovery/Web-Content/common.txt          ← directorios comunes
SecLists/Discovery/Web-Content/raft-medium-files.txt ← archivos comunes
SecLists/Usernames/top-usernames-shortlist.txt     ← usuarios frecuentes
SecLists/Passwords/Common-Credentials/top-20-common-SSH-passwords.txt
SecLists/Fuzzing/SQLi/Generic-SQLi.txt             ← payloads SQL injection
SecLists/Fuzzing/XSS/XSS-Jhaddix.txt              ← payloads XSS

# Acceder: pestaña Decoder (o clic derecho → Send to Decoder)

## Codificaciones disponibles:
URL encoding      → %3C%73%63%72%69%70%74%3E  ↔  <script>
HTML entities     → &lt;script&gt;          ↔  <script>
Base64            → SGVsbG8gV29ybGQ=          ↔  Hello World
Hex               → 48 65 6c 6c 6f            ↔  Hello
ASCII hex         → 0x48656c6c6f              ↔  Hello
Gzip              → (datos comprimidos)       ↔  texto plano
JWT               → header.payload.signature  ↔  JSON legible

# Tip: puedes encadenar múltiples decodificaciones
# URL decode → Base64 decode → Gzip decompress, todo en el mismo panel

# Enviar items a Comparer:
Desde HTTP History: clic derecho → "Send to Comparer" (Request o Response)
Desde Repeater: clic derecho en el panel → "Send to Comparer"
Directamente: pegar texto en los dos paneles de Comparer

# Ver diferencias:
Comparer → seleccionar los dos items → "Compare" → Words o Bytes
- Words: diferencias a nivel de palabra (mejor para HTML/JSON)
- Bytes: diferencias a nivel de byte (mejor para datos binarios)
Las diferencias se resaltan en amarillo/rojo

# Casos de uso prácticos:
- Respuesta con credenciales válidas vs inválidas → qué cambia?
- Respuesta con usuario admin vs usuario normal → se muestran más datos?
- Dos versiones del mismo token → son realmente aleatorios?

# Enviar una petición que genera tokens al Sequencer:
HTTP History → clic derecho en petición de login o generación de token
→ "Send to Sequencer"

# Configurar qué parte de la respuesta contiene el token:
Sequencer → Token Location → seleccionar el campo de la respuesta
(Cookie, Set-Cookie, o Custom location con expresión)

# Ejecutar el análisis:
→ "Start live capture" → Burp envía la petición repetidamente (500-1000 veces)
→ captura los tokens generados → analiza su entropía estadística

# Interpretar resultados:
Entropía efectiva > 100 bits → BIEN: token seguro
Entropía efectiva < 64 bits  → MAL: token potencialmente predecible
Patrones detectados → CRÍTICO: token con estructura predecible

# Para extensiones de GitHub o fuera del BApp Store

## Si la extensión está en Python (necesita Jython)
# 1. Descargar Jython standalone JAR desde jython.org
# 2. En Burp: Extensions → Extensions settings → Python environment
#    → seleccionar el .jar de Jython descargado

## Instalar extensión manual:
Extensions → Installed → Add
→ Extension type: Java / Python / Ruby
→ Extension file: seleccionar el .jar o .py descargado
→ Next → la extensión se carga

## Ejemplo: instalar Turbo Intruder manualmente si no está en la tienda
git clone https://github.com/PortSwigger/turbo-intruder.git
# Compilar o usar el .jar precompilado de Releases → instalar como arriba

## Ver errores de carga de extensiones:
Extensions → Installed → seleccionar extensión → pestaña "Errors"
Útil para diagnosticar por qué una extensión no carga correctamente

# extension_basica.py
# Extensión que añade una cabecera personalizada a todas las peticiones
# Instalar: Extensions → Add → Python → seleccionar este archivo

from burp import IBurpExtender, IHttpListener

class BurpExtender(IBurpExtender, IHttpListener):

    def registerExtenderCallbacks(self, callbacks):
        """Se ejecuta al cargar la extensión"""
        self._callbacks = callbacks
        self._helpers = callbacks.getHelpers()

        # Nombre que aparece en la lista de extensiones
        callbacks.setExtensionName("GhostAcademy - Cabecera Custom")

        # Registrar como listener HTTP — se llamará en cada petición/respuesta
        callbacks.registerHttpListener(self)

        print("[+] Extensión cargada correctamente")

    def processHttpMessage(self, toolFlag, messageIsRequest, messageInfo):
        """Se ejecuta en cada petición o respuesta"""

        # Solo procesar peticiones (no respuestas)
        if not messageIsRequest:
            return

        # Obtener la petición actual
        request = messageInfo.getRequest()
        analyzedRequest = self._helpers.analyzeRequest(request)

        # Obtener las cabeceras actuales
        headers = list(analyzedRequest.getHeaders())

        # Añadir nuestra cabecera personalizada
        headers.append("X-GhostAcademy-Test: auditoria-autorizada")

        # Obtener el cuerpo de la petición
        body = request[analyzedRequest.getBodyOffset():]

        # Reconstruir la petición con la nueva cabecera
        nueva_peticion = self._helpers.buildHttpMessage(headers, body)

        # Reemplazar la petición original
        messageInfo.setRequest(nueva_peticion)
[+] Extensión cargada correctamente
← desde ahora, todas las peticiones llevan la cabecera X-GhostAcademy-Test

# Extensión que extrae URLs y rutas de las respuestas HTTP
from burp import IBurpExtender, IHttpListener
import re

class BurpExtender(IBurpExtender, IHttpListener):

    def registerExtenderCallbacks(self, callbacks):
        self._callbacks = callbacks
        self._helpers = callbacks.getHelpers()
        callbacks.setExtensionName("GhostAcademy - Extractor de Endpoints")
        callbacks.registerHttpListener(self)
        self.endpoints_encontrados = set()
        print("[+] Extractor de endpoints activo")

    def processHttpMessage(self, toolFlag, messageIsRequest, messageInfo):
        if messageIsRequest:
            return

        # Obtener el cuerpo de la respuesta como string
        response = messageInfo.getResponse()
        analyzedResponse = self._helpers.analyzeResponse(response)
        body_offset = analyzedResponse.getBodyOffset()
        body = response[body_offset:].tostring().decode('utf-8', errors='ignore')

        # Buscar URLs relativas y endpoints de API
        patron_api = r'["\'](?:\/api\/[a-zA-Z0-9_\/\-\.]+)["\']'
        patron_ruta = r'["\'](?:\/[a-zA-Z0-9_\/\-\.]+)["\']'

        for match in re.findall(patron_api, body):
            endpoint = match.strip('"\'')
            if endpoint not in self.endpoints_encontrados:
                self.endpoints_encontrados.add(endpoint)
                print(f"[ENDPOINT] {endpoint}")

## PROXY
Intercept ON/OFF    → pestaña Proxy → Intercept → botón
Forward             → reenviar petición pausada
Drop                → descartar petición pausada
Action              → menú de envío a otras herramientas

## REPEATER
Ctrl+R              → enviar petición al Repeater
Ctrl+Enter          → enviar petición en Repeater
← →                 → navegar historial de envíos
Ctrl++              → nueva pestaña de Repeater

## INTRUDER
Ctrl+I              → enviar al Intruder
Positions           → marcar posiciones con §§
Payloads            → configurar lista de payloads
Start attack        → iniciar el ataque
Ordenar por Length  → detectar respuestas diferentes

## DECODER
Ctrl+B              → encode como Base64
Ctrl+Shift+B        → decode Base64
Ctrl+U              → URL encode
Ctrl+Shift+U        → URL decode

## FILTROS ÚTILES EN HTTP HISTORY
Filtrar por código: 200, 302, 401, 403, 500
Filtrar por extensión: php, aspx, json
Filtrar por texto en URL: /api, /admin, /upload
Mostrar solo in-scope: para reducir el ruido