Burp Suite Professional

Web Application Pentesting y Automatización

---

Autor: ViciousByte Security Team Nivel: Intermedio - Avanzado Duración: 10-12 horas de lectura práctica Versión: 1.0 Última actualización: June 2026

---

Lo que vas a dominar

Una guía práctica y densa sobre Burp Suite Professional, de nivel Intermedio - Avanzado, con Burp Suite, Intruder, Scanner, Extensions, Collaborator.

• Instalación y configuración profesional (Linux, Windows, macOS y Docker)
• Comandos y flujos de trabajo del mundo real, explicados línea por línea
• Casos prácticos y troubleshooting con soluciones probadas
• Scripts y plantillas listos para usar

Duración: 10-12 horas de lectura práctica · Nivel: Intermedio - Avanzado

---

Burp Suite Professional: Guía Premium de Maestría en Web Security Testing

Introducción

---

1. Bienvenida y Contexto

En 2025, las aplicaciones web no son simplemente sitios — son la infraestructura operativa de bancos, hospitales, gobiernos y corporaciones globales. Cada transacción financiera, cada historia clínica, cada secreto industrial fluye a través de APIs REST, GraphQL, WebSockets y SPAs que mutan más rápido de lo que los equipos de seguridad pueden auditar. Burp Suite Professional no es una herramienta más: es el estándar de facto que separa a los testers manuales de los profesionales que facturan $150-300 USD por hora.

Las cifras son contundentes. El 2024 OWASP Top 10 reporta que el 78% de las aplicaciones probadas contienen al menos una vulnerabilidad de severidad alta o crítica. El Verizon DBIR 2024 atribuye el 43% de las brechas a fallos en la capa de aplicación web. PortSwigger, la empresa detrás de Burp Suite, cuenta con más de 70,000 organizaciones licenciadas y una comunidad de 300,000+ investigadores que utilizan sus extensiones en el BApp Store. En bug bounty, el 90% de los hallazgos de alto impacto reportados en plataformas como HackerOne e Intigriti pasaron por Burp Suite en algún punto de su explotación.

La evolución de la herramienta ha sido quirúrgica. Desde la versión 2020.1 con el nuevo dashboard de scanning, pasando por la integración nativa de HTTP/2 en 2021, hasta el motor de detección de vulnerabilidades out-of-band mediante Burp Collaborator — cada iteración ha respondido a un panorama donde los WAFs son más inteligentes, las CDNs ocultan la lógica real del servidor, y los tokens CSRF se regeneran por request. La versión 2024.x introduce el Burp Suite Navigator (análisis de superficie de ataque automatizado) y mejoras en el escaneo de APIs basadas en especificaciones OpenAPI 3.1.

Esta guía no te enseñará a "usar Burp". Te enseñará a pensar con Burp. A convertir una sesión de testing en una cadena de explotación reproducible. A escribir extensiones en Python y Java que automaticen lo que otros hacen manualmente durante horas. A leer una respuesta HTTP y saber, por el orden de los headers, si detrás hay un nginx mal configurado, un AWS ALB filtrando tráfico, o un backend en Spring Boot vulnerable a deserialización.

---

2. ¿Para Quién es Esta Guía?

Perfil del lector ideal:

Eres un profesional de seguridad ofensiva con al menos 6-12 meses de experiencia realizando pruebas manuales. Has usado OWASP ZAP, manejas curl y entiendes el modelo request-response de HTTP/1.1. Has encontrado un XSS reflejado y sabes qué es un SQLi basado en UNION. Pero te frustra no poder escalar: los bugs críticos se te escapan, no automatizas tareas repetitivas, y cuando el target implementa protecciones anti-CSRF o rate limiting, te quedas sin opciones.

Prerrequisitos técnicos concretos:

• Comprensión sólida del protocolo HTTP (métodos, headers, cookies, caching, CORS, CSP).
• Familiaridad con al menos un lenguaje de scripting (Python 3.8+ recomendado; Java 11+ para extensiones avanzadas).
• Conceptos de criptografía aplicada: encoding vs encryption, Base64, JWT, HMAC.
• Experiencia básica con Burp Suite Community Edition (proxy, repeater, decoder).
• Conocimiento de OWASP Top 10 (2021) y capacidad de explicar cada categoría con un ejemplo real.

Qué aprenderás exactamente:

Al finalizar esta guía, serás capaz de:

1. Configurar Burp Suite Professional con upstream proxies, certificados CA personalizados, y reglas de scope que filtren ruido automáticamente.
2. Utilizar Intruder con payloads complejos (cluster bomb, pitchfork) y generadores de payloads personalizados para fuzzing de parámetros, IDs secuenciales, y tokens JWT.
3. Dominar Burp Scanner en modo activo y pasivo, interpretando cada finding con su evidencia cruda y request/response de prueba.
4. Explotar vulnerabilidades out-of-band mediante Burp Collaborator para detectar SSRF ciegos, inyecciones de comandos asíncronas, y exfiltración de datos vía DNS/HTTP.
5. Escribir extensiones propias en Python (usando la API de Burp Extender) para automatizar tareas como decodificación de tokens, firmado de requests, o integración con herramientas externas (sqlmap, ffuf, nuclei).
6. Realizar pruebas de seguridad en APIs REST y GraphQL, incluyendo detección de IDORs masivos, inyección de queries GraphQL, y abuso de rate limiting.
7. Montar un pipeline de CI/CD que ejecute escaneos de Burp Suite Professional desde línea de comandos (usando la API REST de Burp) y genere reports en HTML/XML para compliance (PCI DSS, ISO 27001).

---

3. Qué Hace Diferente a Esta Guía

El mercado está inundado de tutoriales que te muestran cómo interceptar una request con el proxy y modificar un parámetro. Eso lo aprendes en 20 minutos. Esta guía opera en otro plano.

Enfoque práctico vs teórico:

Cada capítulo incluye un escenario real extraído de tests de penetración facturados a clientes reales (anonimizados). No te digo "el parámetro id podría ser vulnerable a SQLi". Te muestro una request real contra un endpoint de una API bancaria, el payload exacto que bypasseó el WAF de Cloudflare, y la respuesta del servidor que devolvió la tabla users completa. Luego te explico por qué ese payload funcionó (codificación Unicode, fragmentación de tokens, uso de comentarios inline) y cómo automatizar la detección con Intruder + grep matching.

Ejemplos reales del mundo laboral:

• Capítulo 5: Bypass de autenticación OAuth 2.0 en un SSO corporativo usando redirect_uri manipulation + state parameter fixation. Incluye el flujo completo de requests, el script en Python que automatiza el ataque, y el reporte ejecutivo que entregué al CISO.
• Capítulo 8: Explotación de un SSRF ciego en un microservicio interno de AWS que permitió leer metadatos de EC2 (169.254.169.254) y extraer credenciales IAM temporales. Uso de Collaborator como canal OOB y extracción vía DNS exfiltration.
• Capítulo 12: Automatización de la detección de IDORs en una API REST con 14,000 endpoints. Script en Python que parsea la colección de Postman, genera requests secuenciales con tokens de diferentes roles, y compara respuestas usando fuzzy hashing (ssdeep) para identificar endpoints que retornan datos de otros usuarios.

Scripts y comandos listos para usar:

No hay placeholders. Cada script está completo, probado en Burp Suite Professional 2024.5.1 sobre Java 17, y documentado línea por línea. Ejemplo del Capítulo 7 — extensión para firmar requests con HMAC-SHA256 dinámicamente:

from burp import IBurpExtender, ISessionHandlingAction
from javax.crypto import Mac
from javax.crypto.spec import SecretKeySpec
import base64, hmac, hashlib, time

class BurpExtender(IBurpExtender, ISessionHandlingAction):
def registerExtenderCallbacks(self, callbacks):
self._callbacks = callbacks
callbacks.registerSessionHandlingAction(self)
print("[+] HMAC Signer loaded — ready to sign requests")

def getActionName(self):
return "HMAC-SHA256 Signer"

def performAction(self, currentRequest, macroItems):
requestInfo = self._callbacks.getHelpers().analyzeRequest(currentRequest)
headers = requestInfo.getHeaders()
body = currentRequest.getRequest()[requestInfo.getBodyOffset():]
timestamp = str(int(time.time()))
message = timestamp + body.tostring()
secret = "pre-shared-key-from-client"
signature = hmac.new(secret.encode(), message.encode(), hashlib.sha256).hexdigest()
headers.add("X-Signature: " + signature)
headers.add("X-Timestamp: " + timestamp)
return self._callbacks.getHelpers().buildHttpMessage(headers, body)

Este script se carga en Burp, y automáticamente firma cada request que pase por el proxy con el algoritmo que el backend espera. Sin él, no podrías testear el endpoint porque rechazaría requests sin firma válida.

Troubleshooting de problemas comunes:

Cada capítulo termina con una sección de "Problemas Reales y Soluciones". Ejemplos:

• "Intruder no muestra diferencias en las respuestas aunque sé que el parámetro es vulnerable" → Solución: configurar grep extract con regex que capture el error específico del backend (e.g., SQLSTATE), no solo el status code.
• "Burp Collaborator no recibe interacciones aunque el servidor target resuelve DNS externos" → Solución: verificar que el payload inyectado use el dominio completo de Collaborator (xxx.oastify.com) y que el target no tenga egress filtering a UDP/53. Alternativa: usar HTTP polling con Collaborator.
• "El Scanner marca falsos positivos en un endpoint con WAF" → Solución: ajustar las opciones de scan para excluir parámetros que el WAF bloquea con 403, o usar mode "passive only" y luego validar manualmente con Repeater.

---

4. Estructura de la Guía

La guía sigue una progresión quirúrgica: desde la configuración del entorno hasta la automatización de escaneos en pipelines DevOps.

Capítulo 1 — Configuración Maestra: Instalación, licenciamiento, upstream proxies (para integrar con VPNs y SOCKS5), certificados CA en dispositivos móviles y navegadores, y configuración de scope avanzado con regex para excluir CDNs, analytics, y dominios de terceros.

Capítulo 2 — Proxy y Repeater como Instrumentos de Precisión: Interceptación selectiva, reglas de match/replace, filtros por MIME type, y uso de Repeater con session handling rules para mantener sesiones autenticadas automáticamente.

Capítulo 3 — Intruder: La Máquina de Fuzzing: Payloads simples, listas, números, fechas, y generadores personalizados. Modos de ataque: sniper, battering ram, pitchfork, cluster bomb. Técnicas de grep matching y extracción de datos con expresiones regulares.

Capítulo 4 — Burp Scanner Profesional: Configuración de scan profiles, interpretación de issues (confidence, severity, evidence), auditoría de falsos positivos, y generación de reports ejecutivos y técnicos.

Capítulo 5 — Burp Collaborator: Explotación Out-of-Band: Detección de SSRF, inyección de comandos asíncrona, exfiltración DNS/HTTP, y uso de Collaborator en entornos con restricciones de red.

Capítulo 6 — Extensiones y Automatización: API de Burp Extender en Python y Java. Creación de extensiones para tareas reales: firmado de requests, integración con sqlmap, decodificación automática de tokens JWT, y envío de hallazgos a Slack/Jira.

Capítulo 7 — Testing de APIs Modernas: REST, GraphQL, WebSockets. Descubrimiento de endpoints ocultos, fuzzing de schemas, y detección de vulnerabilidades específicas de APIs (BFLA, mass assignment, inyección de queries GraphQL).

Capítulo 8 — Casos de Estudio de Explotación Real: Tres casos completos de principio a fin: bypass de autenticación OAuth, explotación de SSRF en AWS, y cadena de vulnerabilidades para RCE en un CMS headless.

Capítulo 9 — Integración en CI/CD y Automatización: Uso de la API REST de Burp Suite Professional para ejecutar escaneos desde Jenkins/GitLab CI, generación de reports JUnit, y fail/pass condicional según severidad.

Metodología de aprendizaje: Cada capítulo incluye ejercicios prácticos con entornos vulnerables (PortSwigger Web Security Academy, DVGA, OWASP Juice Shop) y soluciones detalladas. No avances al siguiente capítulo hasta que puedas reproducir los ataques sin mirar la solución.

---

5. Disclaimer Legal y Ético

Esta guía es un instrumento educativo diseñado exclusivamente para profesionales de seguridad autorizados. El conocimiento aquí contenido debe aplicarse únicamente en sistemas sobre los que tengas permiso explícito por escrito para realizar pruebas de penetración. Cualquier uso no autorizado constituye un delito en la mayoría de jurisdicciones, incluyendo pero no limitado a la Computer Fraud and Abuse Act (CFAA) en EE.UU., la Computer Misuse Act en Reino Unido, y el Código Penal en países de la UE y Latinoamérica.

Responsabilidades del lector:

• Obtener autorización documentada antes de ejecutar cualquier técnica descrita en esta guía contra un sistema que no sea de tu propiedad.
• Cumplir con las leyes locales, estatales y federales aplicables en tu jurisdicción.
• Seguir estándares profesionales como el PTES (Penetration Testing Execution Standard) y las guías de OWASP.
• Reportar vulnerabilidades de manera responsable, dando tiempo razonable al vendor para su corrección antes de cualquier divulgación pública.

Contexto profesional:

Las técnicas aquí descritas son utilizadas diariamente por consultores de seguridad, equipos de red team internos, y bug bounty hunters que operan dentro de marcos legales y éticos. El autor y el editor no asumen responsabilidad alguna por el uso indebido de esta información. Si tienes dudas sobre la legalidad de una acción, consulta con un abogado especializado en derecho tecnológico antes de proceder.

Política de divulgación responsable:

Si encuentras una vulnerabilidad real mientras practicas con entornos autorizados, sigue el estándar ISO 29147:2018 para divulgación de vulnerabilidades. Esta guía incluye plantillas de reporte y comunicación con vendors en el Apéndice B.

---

6. Certificaciones y Carrera

Dominar Burp Suite Professional no es un fin en sí mismo — es el vehículo para alcanzar certificaciones que multiplican tu valor de mercado.

Certificaciones directamente relacionadas:

• PortSwigger Web Security Academy (gratuita): Completa todos los laboratorios (200+) y obtén el certificado de Burp Suite Certified Practitioner (BSCP). Es el estándar de la industria para demostrar competencia práctica con la herramienta. El examen es 100% hands-on: 4 horas, dos aplicaciones vulnerables, debes encontrar y explotar vulnerabilidades específicas usando Burp Suite Professional.
• Offensive Security Web Expert (OSWE): La certificación avanzada de web application security de OffSec. El examen de 48 horas requiere explotar aplicaciones web reales con bypass de autenticación, inyección de código, y escalada de privilegios. Burp Suite es la herramienta principal.
• Certified Red Team Operator (CRTO): De Zero-Point Security, enfocada en adversary simulation. Incluye módulos de explotación web con Burp Suite como parte de cadenas de ataque más amplias (phishing → creds → web app → DA).
• SANS GWAPT (GIAC Web Application Penetration Tester): El curso SEC542 cubre Burp Suite extensivamente. El examen GIAC es reconocido en DoD 8570 y sector financiero.

Oportunidades laborales y tarifas (2025):

• Pentester Junior (0-2 años): $60,

---

Burp Suite Professional: Guía Premium de Maestría en Web Security Testing

Capítulo 1: Fundamentos y Setup Profesional

---

1.1 ¿Qué es Burp Suite?

Burp Suite es una plataforma integrada de pruebas de seguridad para aplicaciones web, desarrollada por PortSwigger. Actúa como un proxy interceptante que se sitúa entre el navegador del tester y la aplicación objetivo, permitiendo inspeccionar, modificar y automatizar el tráfico HTTP/HTTPS. Su arquitectura modular cubre todo el ciclo de vida de un test de penetración web: mapeo de superficie de ataque, análisis de vulnerabilidades, explotación manual y generación de reportes.

Historia y evolución: Lanzado en 2004 por Dafydd Stuttard como una herramienta personal, Burp Suite se convirtió en el estándar de facto para pentesting web. La versión Professional (de pago) añadió el escáner automatizado, Burp Collaborator para detección de vulnerabilidades out-of-band, y funciones avanzadas de reporting. En 2024, PortSwigger introdujo el motor de escaneo basado en navegador (Burp Browser) y mejoras en la detección de vulnerabilidades de lógica de negocio.

Casos de uso reales en empresas:

• Equipos de seguridad ofensiva en consultoras (Deloitte, EY, KPMG) lo utilizan como herramienta principal en auditorías de aplicaciones web.
• Programas de Bug Bounty: plataformas como HackerOne e Intigriti recomiendan Burp Suite Professional para cazadores de recompensas.
• Equipos internos de AppSec en empresas como Google, Microsoft y Amazon lo integran en pipelines de CI/CD para escaneo automatizado.
• Formación: PortSwigger Academy, gratuita, es el recurso de entrenamiento más completo para aprender web hacking.

Comparación con alternativas:

| Herramienta | Proxy Interceptante | Escáner Automatizado | Fuzzing | Extensibilidad | Precio (USD/año) | |-------------|---------------------|----------------------|---------|----------------|------------------| | Burp Suite Pro | Sí (avanzado) | Sí (motor propio) | Intruder (cluster bomb, pitchfork) | BApp Store + API Java/Python | $449 | | OWASP ZAP | Sí | Sí (basado en reglas) | Fuzzer básico | Add-ons ZAP | Gratis | | Fiddler Everywhere | Sí | No | No | Limitada | $144 | | Charles Proxy | Sí | No | No | No | $50 | | mitmproxy | Sí (CLI) | No | No | Scripts Python | Gratis | | Caido | Sí | No | Sí (workflows) | GraphQL API | $200 |

Ventajas de Burp Suite Pro:

• Motor de escaneo activo/pasivo con detección de vulnerabilidades OWASP Top 10, lógica de negocio y out-of-band (OAST).
• Burp Collaborator: servidor externo que detecta interacciones DNS/HTTP/SMTP para identificar blind SSRF, XXE, inyecciones asíncronas.
• Intruder con múltiples modos de ataque y payloads personalizados.
• Extensibilidad vía BApp Store (más de 200 extensiones) y API Montoya (Java/Python).
• Integración con CI/CD mediante REST API y línea de comandos.

Limitaciones:

• Requiere Java Runtime (JRE 17+), lo que puede ser pesado en recursos.
• La versión Community es muy limitada (sin escáner, Intruder throttled, sin Collaborator).
• Curva de aprendizaje pronunciada para aprovechar todas sus capacidades.
• No es una herramienta de explotación pura (no incluye exploits preempaquetados como Metasploit), sino de detección y manipulación.

---

1.2 Arquitectura y Componentes

Burp Suite está construido sobre una arquitectura modular en Java, con un núcleo central que gestiona el proxy HTTP/HTTPS y la persistencia de datos. Cada componente se comunica a través de un bus interno de mensajes, permitiendo que los datos fluyan entre herramientas.

Componentes principales:

1. Proxy: Intercepta, visualiza y modifica tráfico HTTP/HTTPS entre navegador y servidor. Incluye reglas de interceptación, filtros por MIME type, y soporte para WebSockets.
2. Scanner (Pro): Motor de escaneo activo y pasivo. El escaneo pasivo analiza tráfico en tránsito sin enviar peticiones; el activo envía payloads para confirmar vulnerabilidades. Utiliza técnicas de crawling, auditing y detección OAST.
3. Intruder: Herramienta de fuzzing y automatización de ataques parametrizados. Permite definir posiciones de payload, modos de ataque (sniper, battering ram, pitchfork, cluster bomb) y procesadores de payload.
4. Repeater: Manipulación manual de peticiones individuales, con historial de modificaciones y capacidad de enviar múltiples peticiones en paralelo.
5. Sequencer: Análisis de aleatoriedad de tokens (session cookies, CSRF tokens) mediante tests estadísticos (FIPS 140-2, chi-cuadrado, etc.).
6. Decoder: Codificación/decodificación de datos en múltiples formatos (URL, Base64, Hex, HTML entities, etc.) con soporte para hashing.
7. Comparer: Comparación visual y binaria de dos conjuntos de datos (peticiones, respuestas, archivos).
8. Extender: API para desarrollar extensiones en Java (Montoya API) o Python (Jython). Permite agregar nuevas funcionalidades, checks de escaneo personalizados, y automatización.
9. Collaborator (Pro): Infraestructura externa que proporciona dominios y servidores para detectar interacciones out-of-band. El cliente genera payloads únicos que, al ser ejecutados por el servidor vulnerable, generan consultas DNS o HTTP capturadas por el servidor Collaborator.
10. Burp Browser: Navegador Chromium integrado y preconfigurado para trabajar con el proxy, evitando problemas de certificados.

Dependencias y librerías:

• Java Runtime Environment (JRE) 17 o superior (OpenJDK recomendado).
• Jython 2.7.3 (para extensiones Python).
• Librerías internas: Montoya API, Bouncy Castle (criptografía), Jetty (servidor web embebido para Collaborator), SQLite (persistencia de proyectos).

Flujo de trabajo típico:

1. Configurar proxy (listener en 127.0.0.1:8080).
2. Instalar certificado CA de Burp en el navegador o dispositivo.
3. Navegar por la aplicación objetivo para poblar el site map (crawling pasivo).
4. Ejecutar escaneo pasivo para identificar vulnerabilidades superficiales.
5. Realizar spidering activo para descubrir contenido oculto.
6. Lanzar escaneo activo sobre endpoints interesantes.
7. Usar Intruder para fuzzing de parámetros sospechosos.
8. Validar hallazgos manualmente con Repeater.
9. Generar reporte profesional.

Diagrama conceptual (ASCII):

+----------------+ +------------------+ +-----------------+
| Navegador |<----->| Burp Proxy |<----->| Servidor Web |
| (Burp Browser) | | (127.0.0.1:8080) | | (objetivo) |
+----------------+ +------------------+ +-----------------+
| ^
v |
+--------+---------+--------+
| Bus Interno |
+--------+---------+--------+
| ^
+--------------------+ +--------------------+
| |
+--------v--------+ +--------v--------+ +--------v--------+
| Scanner Activo | | Intruder | | Repeater |
+-----------------+ +----------------+ +-----------------+
| |
+--------v--------+ +--------v--------+ +--------v--------+
| Collaborator | | Extender | | Sequencer |
| (servidor ext) | | (BApp Store) | | (análisis) |
+-----------------+ +----------------+ +-----------------+

---

1.3 Instalación Paso a Paso

Requisitos del Sistema

• Hardware mínimo: CPU 2 núcleos, 4 GB RAM (8 GB recomendado para escaneos grandes), 2 GB espacio en disco.
• Sistema operativo: Linux (Ubuntu 20.04+, Debian 11+, CentOS 8+, RHEL 8+), Windows 10/11 (64-bit), macOS 11+ (Intel/M1/M2).
• Dependencias previas: Java 17+ (OpenJDK o Oracle JDK). En Linux/macOS, curl o wget para descarga.

Descarga e Instalación

Linux (Ubuntu/Debian):

## 1. Instalar Java 17 (OpenJDK)
sudo apt update && sudo apt install -y openjdk-17-jre-headless

## 2. Descargar Burp Suite Professional (última versión estable)
## URL oficial: https://portswigger.net/burp/releases/professional/latest
wget -O burpsuite_pro.jar "https://portswigger.net/burp/releases/download?product=pro&version=latest&type=jar"

## 3. Verificar integridad (opcional, PortSwigger no publica hashes oficiales, pero puedes comparar con descargas previas)
sha256sum burpsuite_pro.jar

## 4. Crear directorio de trabajo y mover el JAR
mkdir -p ~/burpsuite && mv burpsuite_pro.jar ~/burpsuite/

## 5. Crear script de lanzamiento para facilitar ejecución
cat > ~/burpsuite/burp.sh << 'EOF'
#!/bin/bash
java -Xmx4g -jar ~/burpsuite/burpsuite_pro.jar "$@"
EOF
chmod +x ~/burpsuite/burp.sh

## 6. Ejecutar Burp Suite
~/burpsuite/burp.sh

Linux (RedHat/CentOS/RHEL):

## 1. Instalar Java 17 (OpenJDK)
sudo dnf install -y java-17-openjdk-headless # CentOS 8+, RHEL 8+
## Para CentOS 7, habilitar EPEL y usar alternativas

## 2. Descargar Burp Suite Professional
curl -L -o burpsuite_pro.jar "https://portswigger.net/burp/releases/download?product=pro&version=latest&type=jar"

## 3. Crear directorio y script de lanzamiento
mkdir -p /opt/burpsuite && mv burpsuite_pro.jar /opt/burpsuite/
cat > /opt/burpsuite/burp.sh << 'EOF'
#!/bin/bash
java -Xmx4g -jar /opt/burpsuite/burpsuite_pro.jar "$@"
EOF
chmod +x /opt/burpsuite/burp.sh

## 4. Ejecutar
/opt/burpsuite/burp.sh

Windows:

1. Descargar el instalador desde: https://portswigger.net/burp/releases/professional/latest (seleccionar "Windows (64-bit)").
2. Ejecutar el archivo .exe descargado. El instalador incluye un JRE embebido, por lo que no necesitas instalar Java por separado.
3. Seguir el asistente: aceptar licencia, elegir ruta de instalación (por defecto C:\Program Files\BurpSuitePro).
4. Al finalizar, se crea un acceso directo en el escritorio y en el menú Inicio.
5. Para lanzar desde línea de comandos (PowerShell):

## Ajustar memoria máxima (opcional)
$env:JAVA_TOOL_OPTIONS="-Xmx4g"
& "C:\Program Files\BurpSuitePro\BurpSuitePro.exe"

6. Variables de entorno útiles:

• BURP_PATH: apuntar al directorio de instalación.
• JAVA_HOME: si usas Java externo, configurar a la ruta del JDK/JRE.

macOS:

## 1. Instalar Java 17 (si no está presente)
brew install openjdk@17
## Enlazar simbólicamente para que el sistema lo reconozca
sudo ln -sfn $(brew --prefix)/opt/openjdk@17/libexec/openjdk.jdk /Library/Java/JavaVirtualMachines/openjdk-17.jdk

## 2. Descargar Burp Suite Professional (JAR)
curl -L -o ~/Downloads/burpsuite_pro.jar "https://portswigger.net/burp/releases/download?product=pro&version=latest&type=jar"

## 3. Mover a Applications y crear script
mkdir -p ~/Applications/BurpSuite
mv ~/Downloads/burpsuite_pro.jar ~/Applications/BurpSuite/
cat > ~/Applications/BurpSuite/burp.sh << 'EOF'
#!/bin/bash
java -Xmx4g -jar ~/Applications/BurpSuite/burpsuite_pro.jar "$@"
EOF
chmod +x ~/Applications/BurpSuite/burp.sh

## 4. Ejecutar
~/Applications/BurpSuite/burp.sh

Troubleshooting M1/M2 (Apple Silicon):

• Asegúrate de usar OpenJDK para ARM64 (brew install openjdk@17 ya proporciona la versión nativa).
• Si experimentas lentitud gráfica, añade -Dsun.java2d.metal=true a los parámetros de Java para usar el renderizado Metal en lugar de OpenGL.

Docker:

## Dockerfile
FROM eclipse-temurin:17-jre-alpine

RUN apk add --no-cache curl bash

WORKDIR /opt/burp

## Descargar Burp Suite Professional (requiere licencia válida)
RUN curl -L -o burpsuite_pro.jar "https://portswigger.net/burp/releases/download?product=pro&version=latest&type=jar"

## Copiar licencia (debes tener el archivo burp-license.key en el contexto de build)
COPY burp-license.key /opt/burp/

## Script de entrada
COPY entrypoint.sh /opt/burp/
RUN chmod +x /opt/burp/entrypoint.sh

## Exponer puerto del proxy (puedes mapear en docker-compose)
EXPOSE 8080

ENTRYPOINT ["/opt/burp/entrypoint.sh"]

## docker-compose.yml
version: '3.8'
services:
burp:
build: .
container_name: burpsuite_pro
ports:
- "8080:8080" # Proxy listener
- "9090:9090" # Opcional: API REST (si se habilita)
volumes:
- ./projects:/opt/burp/projects # Persistencia de proyectos
- ./config:/opt/burp/config # Configuraciones personalizadas
environment:
- JAVA_OPTS=-Xmx4g -Djava.awt.headless=true
stdin_open: true
tty: true

## entrypoint.sh

---

## 🔒 Burp Suite Professional: Guía Premium de Maestría en Web Security Testing

## Capítulo 2: Técnicas Avanzadas

---

### 2.1 Comandos Esenciales

Burp Suite Professional no es solo una GUI; su potencia real se despliega mediante la línea de comandos y la API REST. Aquí tienes los 20 comandos y endpoints que usarás a diario en entornos profesionales. Cada uno incluye sintaxis completa, parámetros críticos y el output que debes esperar.

**1. Lanzar Burp con un proyecto específico**
```bash
java -jar burpsuite_pro.jar --project-file=proyecto.burp

Carga automáticamente la configuración, el scope y el historial del proyecto. Sin esto, empezarías desde cero cada vez.

2. Usar un archivo de configuración personalizado

java -jar burpsuite_pro.jar --config-file=config.json

El JSON puede contener opciones de proxy, scope, extensiones y preferencias de usuario. Ideal para desplegar entornos idénticos en CI/CD.

3. Desactivar actualizaciones automáticas (entornos air-gapped)

java -jar burpsuite_pro.jar --disable-auto-update

Evita intentos de conexión externa que podrían alertar a un SOC.

4. Iniciar Burp en modo headless con API REST habilitada

java -jar burpsuite_pro.jar --headless --api-key=abcdef1234567890

El flag --headless suprime la GUI; la API REST queda expuesta en http://localhost:1337. Sin API key, las peticiones serán rechazadas.

5. Lanzar un escaneo activo mediante API REST

curl -X POST "http://localhost:1337/v0.1/scan" \
-H "Content-Type: application/json" \
-d '{"urls":["https://example.com"],"scan_type":"active"}'

Output esperado:

{"task_id":"a1b2c3d4-...","status":"queued"}

6. Consultar el estado de una tarea

curl "http://localhost:1337/v0.1/scan/a1b2c3d4-..."

Output:

{"status":"running","progress":45,"issues_found":3}

7. Generar un reporte HTML

curl -X POST "http://localhost:1337/v0.1/report" \
-H "Content-Type: application/json" \
-d '{"task_id":"a1b2c3d4-...","format":"html"}'

Devuelve el reporte en base64. Decodifícalo con base64 -d.

8. Pausar/reanudar el spider

curl -X POST "http://localhost:1337/v0.1/spider/pause" # o /resume

9. Listar todas las tareas activas

curl "http://localhost:1337/v0.1/tasks"

Output: array JSON con todas las tareas y sus estados.

10. Configurar el proxy upstream desde CLI

java -jar burpsuite_pro.jar --upstream-proxy=socks5://127.0.0.1:9050

Todo el tráfico de Burp se enruta a través de Tor. Imprescindible para evasión.

11. Definir propiedades del sistema Java

java -Dburp.bypass.auth=true -jar burpsuite_pro.jar

Propiedades como burp.bypass.auth desactivan la autenticación de la API (solo para labs aislados).

12. Cargar extensiones BApp al inicio

java -jar burpsuite_pro.jar --extensions=TurboIntruder,Hackvertor

13. Establecer el scope desde un archivo

java -jar burpsuite_pro.jar --scope-file=scope.txt

scope.txt contiene una URL por línea.

14. Activar el colaborator privado

java -jar burpsuite_pro.jar --collaborator-server=https://collab.miempresa.com

15. Forzar el uso de un perfil de usuario concreto

java -jar burpsuite_pro.jar --user-config-file=user.json

16. Iniciar un escaneo pasivo sobre un archivo HAR

curl -X POST "http://localhost:1337/v0.1/scan" \
-d '{"file":"trafico.har","scan_type":"passive"}'

17. Obtener issues en formato JSON

curl "http://localhost:1337/v0.1/scan/a1b2c3d4-.../issues"

18. Detener una tarea

curl -X DELETE "http://localhost:1337/v0.1/scan/a1b2c3d4-..."

19. Exportar el historial de proxy

curl "http://localhost:1337/v0.1/proxy/history" -o history.json

20. Health check de la API

curl "http://localhost:1337/v0.1/health"

Output: {"status":"ok","version":"2025.2.1"}

Advertencia: La API REST de Burp no está diseñada para exponerse en redes no confiables. Siempre úsala en localhost o mediante un túnel SSH.

---

2.2 Automatización con Scripts

La automatización convierte a Burp en un motor de escaneo continuo. Aquí tienes scripts completos, listos para producción.

Bash: Escaneo nocturno con reporte por correo

#!/bin/bash
## burp_nightly.sh - Lanza Burp headless, escanea una lista de URLs y envía el reporte por email

API_KEY="abc123"
BURP_JAR="/opt/burp/burpsuite_pro.jar"
URL_LIST="urls.txt"
REPORT_DIR="/var/reports/burp"
TIMESTAMP=$(date +%Y%m%d_%H%M)
LOG_FILE="$REPORT_DIR/scan_$TIMESTAMP.log"

mkdir -p "$REPORT_DIR"

## 1. Iniciar Burp en segundo plano
java -jar "$BURP_JAR" --headless --api-key="$API_KEY" &> "$LOG_FILE" &
BURP_PID=$!
sleep 15 # Esperar a que la API esté lista

## 2. Para cada URL, lanzar escaneo activo
while IFS= read -r url; do
echo "[*] Escaneando $url" | tee -a "$LOG_FILE"
TASK_ID=$(curl -s -X POST "http://localhost:1337/v0.1/scan" \
-H "Content-Type: application/json" \
-d "{\"urls\":[\"$url\"],\"scan_type\":\"active\"}" | jq -r '.task_id')
echo " Task ID: $TASK_ID" >> "$LOG_FILE"

    # 3. Esperar a que termine (polling cada 30s, timeout 1h)
for i in {1..120}; do
STATUS=$(curl -s "http://localhost:1337/v0.1/scan/$TASK_ID" | jq -r '.status')
if [[ "$STATUS" == "succeeded" || "$STATUS" == "failed" ]]; then
break
fi
sleep 30
done

    # 4. Generar reporte HTML
REPORT_B64=$(curl -s -X POST "http://localhost:1337/v0.1/report" \
-H "Content-Type: application/json" \
-d "{\"task_id\":\"$TASK_ID\",\"format\":\"html\"}" | jq -r '.report')
echo "$REPORT_B64" | base64 -d > "$REPORT_DIR/${url//[^a-zA-Z0-9]/_}_$TIMESTAMP.html"
echo " Reporte guardado." >> "$LOG_FILE"
done < "$URL_LIST"

## 5. Enviar log por correo (requiere mailutils)
mail -s "Burp Nightly Scan $TIMESTAMP" security@empresa.com < "$LOG_FILE"

## 6. Matar Burp
kill $BURP_PID

Python: Orquestador con logging estructurado

#!/usr/bin/env python3
"""
burp_automator.py - Cliente Python para la API REST de Burp Suite Professional.
Realiza escaneos activos, espera finalización y descarga reportes.
"""

import requests
import time
import json
import logging
import sys
from pathlib import Path

API_BASE = "http://localhost:1337/v0.1"
API_KEY = "abc123"
HEADERS = {"Content-Type": "application/json"}

logging.basicConfig(
level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(message)s",
handlers=[logging.FileHandler("burp_automator.log"), logging.StreamHandler()]
)
logger = logging.getLogger(__name__)

def create_scan(urls: list, scan_type: str = "active") -> str:
"""Lanza un escaneo y devuelve el task_id."""
payload = {"urls": urls, "scan_type": scan_type}
resp = requests.post(f"{API_BASE}/scan", headers=HEADERS, json=payload)
resp.raise_for_status()
task_id = resp.json()["task_id"]
logger.info(f"Escaneo creado: {task_id} para {urls}")
return task_id

def wait_for_completion(task_id: str, timeout: int = 3600, poll_interval: int = 30):
"""Espera hasta que el escaneo termine o expire el timeout."""
start = time.time()
while time.time() - start < timeout:
resp = requests.get(f"{API_BASE}/scan/{task_id}")
data = resp.json()
status = data.get("status")
progress = data.get("progress", 0)
logger.info(f"Task {task_id}: {status} ({progress}%)")
if status in ("succeeded", "failed", "cancelled"):
return status
time.sleep(poll_interval)
raise TimeoutError(f"Timeout esperando task {task_id}")

def download_report(task_id: str, format: str = "html") -> bytes:
"""Obtiene el reporte en el formato especificado y devuelve los bytes decodificados."""
payload = {"task_id": task_id, "format": format}
resp = requests.post(f"{API_BASE}/report", headers=HEADERS, json=payload)
data = resp.json()
import base64
return base64.b64decode(data["report"])

def main():
if len(sys.argv) < 2:
print("Uso: python burp_automator.py <urls.txt>")
sys.exit(1)

with open(sys.argv[1]) as f:
urls = [line.strip() for line in f if line.strip()]

for url in urls:
try:
task_id = create_scan([url])
status = wait_for_completion(task_id)
if status == "succeeded":
report_bytes = download_report(task_id)
safe_name = url.replace("://", "_").replace("/", "_")
Path(f"reports/{safe_name}.html").write_bytes(report_bytes)
logger.info(f"Reporte guardado para {url}")
else:
logger.error(f"Escaneo fallido para {url}: {status}")
except Exception as e:
logger.exception(f"Error procesando {url}")

if __name__ == "__main__":
main()

Cron para ejecución program

---

Burp Suite Professional: Guía Premium de Maestría en Web Security Testing

---

Contenido Premium

Los siguientes capítulos están disponibles en la versión completa:

• Capítulo 3: Análisis de Casos Reales
• Capítulo 4: Ejercicios Prácticos Guiados
• Capítulo 5: Troubleshooting y FAQs
• Capítulo 6: Recursos y Certificaciones
• Scripts completos y plantillas
• Soporte técnico incluido

Desbloquear Contenido Completo