Burp Suite Bambdas en Español

Las Bambdas son pequeños fragmentos de código escritos en Java que te permiten personalizar y extender la funcionalidad de Burp Suite directamente desde su interfaz, sin necesidad de compilar extensiones tradicionales. Estas herramientas son altamente flexibles y ofrecen una forma rápida de ajustar Burp Suite a tus necesidades específicas. Entre otras cosas, las Bambdas te permiten:

  • Filtrar y organizar solicitudes/respuestas HTTP o mensajes WebSocket de manera avanzada.
  • Crear columnas personalizadas que muestren información clave.
  • Automatizar tareas como detectar respuestas sospechosas, analizar tokens JWT o buscar parámetros específicos.

Bambdas en Burp Suite

A continuación, encontrarás una guía completa sobre Bambdas en Burp Suite, organizada en secciones claras para facilitar su comprensión. Desde preguntas frecuentes (FAQ) hasta ejemplos prácticos de código, este artículo te proporcionará toda la información que necesitas para empezar a usar y dominar las Bambdas de manera eficiente. ¡Sigue leyendo y personaliza Burp Suite como un experto!

Índice

¿Por Qué Usar Bambdas?

  • Personalización Instantánea: Ajusta cómo Burp registra y muestra datos sin tener que compilar extensiones tradicionales.
  • Filtrado Potente: Las Bambdas permiten más que simples expresiones regulares; puedes parsear JSON, chequear cabeceras HTTP, etc.
  • Fácil de Usar: Tienes autocompletado y edición de código dentro de Burp Suite, sin entornos externos.
  • Compartibles: Al ser fragmentos cortos, se guardan, comparten y reutilizan fácilmente.

Bambdas en Acción: Casos de Uso Clave

Filtrado del Historial HTTP

  • Objeto principal: ProxyHttpRequestResponse (de la API Montoya).
  • Ubicación: Pestaña Proxy > HTTP history.
  • Uso:
    • Abre la ventana HTTP history filter.
    • Selecciona Bambda mode.
    • Escribe tu snippet de Java.
    • Haz clic en Apply para probar, y luego Apply & close para finalizar.

Ejemplo:

if (!requestResponse.hasResponse()) {
    return false;
}
var response = requestResponse.response();
return response.isStatusCodeClass(StatusCodeClass.CLASS_3XX_REDIRECTION)
       && response.hasCookie("session");

Filtrado del Historial de WebSockets

  • Objeto principal: ProxyWebSocketMessage (de la API Montoya).
  • Ubicación: Pestaña Proxy > WebSockets history.
  • Uso: Muy similar a lo que se hace con el Historial HTTP, pero aplicado a mensajes en lugar de solicitudes/respuestas.

Ejemplo:

return message.payload().length() > 300
       && message.direction() == Direction.SERVER_TO_CLIENT;

Filtrado y Visualización en Burp Logger

En Burp Logger, puedes configurar dos tipos de filtros:

  • Capture filter: Determina qué elementos se capturan en Logger.
  • View filter: Determina qué elementos capturados se muestran en pantalla.

Objetos relevantes:

  • LoggerHttpRequestResponse (para filtros de vista en Logger).
  • LoggerCaptureHttpRequestResponse (para filtros de captura en Logger).

Ejemplo de View Filter: (muestra solicitudes cuyas respuestas tardan más de 1 segundo en comenzar):

if (!requestResponse.hasResponse()) {
    return false;
}
var timingData = requestResponse.timingData();
return timingData.timeBetweenRequestSentAndStartOfResponse().toMillis() > 1000;

Filtrado del Site Map

  • Objeto principal: SiteMapNode.
  • Ubicación: Pestaña Target > Site map.
  • Uso:
    • Haz clic en la barra de filtros en Site map.
    • Selecciona Bambda mode.
    • Escribe tu código.
    • Haz clic en Apply y cierra la ventana.

Ejemplo:

return node.requestResponse().request().method().equals("POST")
       && !node.issues().isEmpty();

Creación de Columnas Personalizadas (Professional)

En la versión Professional, puedes crear columnas personalizadas en:

  • Historial HTTP (Proxy)
  • Historial de WebSockets (Proxy)
  • Logger

Ejemplo: (añadir una columna que muestre la cabecera Server en el Historial HTTP):

if (!requestResponse.hasResponse()) {
    return "";
}
var response = requestResponse.response();
return response.hasHeader("Server")
    ? response.headerValue("Server")
    : "";

Snippets de Código y Ejemplos Prácticos de Bambdas

A continuación, verás algunos ejemplos cortos que podrían serte útiles en tu día a día:

  • Acceder al objeto request:
    •   var request = requestResponse.request();
  • Revisar si existe un parámetro en la solicitud:
    •   var cookie = request.parameter("foo", HttpParameterType.COOKIE);
  if (cookie != null) {
      // Lógica específica
  }
  • Verificar si una respuesta es JSON:
    •   var contentType = requestResponse.response().headerValue("Content-Type");
  if (contentType != null && !contentType.contains("application/json")) {
      String body = requestResponse.response().bodyToString().trim();
      return body.startsWith("{") || body.startsWith("[");
  }
  return false;
  • Parsear un JWT y buscar “role”:
    •   if (requestResponse.response().hasHeader("authorization")) {
      var authValue = requestResponse.response().headerValue("authorization");
      if (authValue.startsWith("Bearer ey")) {
          var tokens = authValue.split("\\.");
          if (tokens.length == 3) {
              var decodedClaims = utilities().base64Utils()
                  .decode(tokens[1], Base64DecodingOptions.URL)
                  .toString();
              return decodedClaims.toLowerCase().contains("role");
          }
      }
  }
  return false;

Creando, Guardando y Cargando Bambdas

Creando una Bambda

  • Ve a la herramienta de Burp que soporte Bambdas (ej. HTTP history, Logger, Site map).
  • Haz clic en la barra de filtros o el menú de opciones (para columnas personalizadas).
  • Selecciona Bambda mode.
  • Escribe tu fragmento de Java.
  • Haz clic en Apply para ver la salida de consola o errores.
  • Si compila con éxito, haz clic en Apply & close.

Guardando una Bambda

  • Haz clic en Settings (ícono de engranaje) en la ventana de Bambda mode.
  • Selecciona Save settings.
  • Burp descargará tu Bambda como un archivo JSON.

Cargando una Bambda

  • En la misma ventana de Bambda mode, haz clic en Settings.
  • Elige Load settings y selecciona el archivo JSON.
  • Haz clic en Apply para cargarla.

Nota: Las Bambdas son específicas de cada herramienta. Un filtro para HTTP history no funciona en Logger o WebSockets.

Solucionando Problemas con Bambdas

  • Errores de Compilación:
    • El editor te los mostrará con subrayados rojos en tiempo real.
    • Puedes pasar el ratón por encima o revisar la pestaña Compilation errors si aplicas la Bambda y falla.
  • Errores de Ejecución:
    • Si ocurren después de aplicar la Bambda, verás una advertencia en la barra de filtros.
    • Haz clic en la advertencia para ver detalles.

Asegúrate de corregir todos los errores antes de volver a aplicar la Bambda.

Rendimiento y Consideraciones de Seguridad

  • Rendimiento:
    Cada elemento (solicitud o mensaje) pasa por la lógica de la Bambda. Si el código es complejo, puede ralentizar Burp. Mantén tu Bambda lo más ligera posible.
  • Seguridad:
    Las Bambdas pueden ejecutar cualquier código Java. Asegúrate de usar fragmentos de fuentes confiables y verifica su contenido antes de aplicarlos.

Contribuir con Bambdas a la Comunidad

PortSwigger mantiene un repositorio oficial de Bambdas en GitHub para que la comunidad colabore.

Pasos para Contribuir

  • Haz un fork al repositorio de Bambdas en GitHub.
  • Crea una nueva rama para tus Bambdas.
  • Añade un archivo .bambda en el directorio apropiado (según el tipo de Bambda y la herramienta).
  • Haz push de los cambios a tu fork y luego crea un pull request.
  • Participa en la revisión y el feedback de la comunidad.

Tip: Usa la herramienta Bambda Checker para verificar y generar un README.md antes de enviar tu aporte.

Ejemplos y Demostraciones Avanzadas

A continuación verás ejemplos más complejos, probados en entornos de investigación de seguridad:

Respuestas de Redirección Grandes

Marca respuestas con código 3xx cuyo cuerpo supere 1000 bytes (posible señal de contenido extra al redirigir):

return requestResponse.hasResponse()
    && requestResponse.response().statusCode() >= 300
    && requestResponse.response().statusCode() <= 399
    && requestResponse.response().body().length() > 1000;

Respuestas con Múltiples </html>

Detecta páginas que podrían tener HTML extra, a veces ocultas detrás de autenticación. Se filtran los no-HTML:

return requestResponse.response().statedMimeType() == MimeType.HTML
    && utilities().byteUtils().countMatches(
        requestResponse.response().body().getBytes(),
        "</html>".getBytes()
    ) > 1;

Content-Length Incorrecta

Ciertos middlewares inyectan contenido adicional sin actualizar la cabecera Content-Length:

int realContentLength = requestResponse.response().body().length();
int declaredContentLength = Integer.parseInt(
    requestResponse.response().headerValue("Content-Length")
);
return declaredContentLength != realContentLength;

Cabeceras HTTP Malformadas

Busca cabeceras con espacios en el nombre (señal de configuraciones extrañas):

return requestResponse.response().headers().stream()
    .anyMatch(e -> e.name().contains(" "));

Endpoints JSON con Tipo MIME Equivocado o Ausente

Verifica si la cabecera Content-Type es text/html pero el cuerpo parece ser JSON:

if(!requestResponse.hasResponse()) {
    return false;
}
var response = requestResponse.response();
if (response.hasHeader("Content-Type")) {
    if (!response.headerValue("Content-Type").contains("text/html")) {
        return false;
    }
}
String body = response.bodyToString().trim();
boolean looksLikeJson = body.startsWith("{") || body.startsWith("[");
return looksLikeJson;

Detección de Endpoints GraphQL

Busca un parámetro llamado query que incluya saltos de línea, algo típico de GraphQL:

var req = requestResponse.request();
if(!req.hasParameters()) {
    return false;
}
var types = new HttpParameterType[]{
    HttpParameterType.JSON, HttpParameterType.BODY, HttpParameterType.URL
};
for(HttpParameterType type : types) {
    if(req.hasParameter("query", type)) {
        var value = req.parameterValue("query", type);
        if(type == HttpParameterType.JSON) {
            if(value.contains("\\n")) {
                return true;
            }
        } else {
            if(value.toLowerCase().contains("%0a")) {
                return true;
            }
        }
    }
}
return false;

Búsqueda de Endpoints JSONP

Localiza parámetros de callback que se reflejan en la respuesta:

var req = requestResponse.request();
var res = requestResponse.response();
var paramRegex = Pattern.compile("^[a-zA-Z][.\\w]{4,}$");

if(res == null || res.body().length() == 0) return false;
if(!req.hasParameters()) return false;

var body = res.bodyToString().trim();
var params = req.parameters();

for(var param: params) {
    var value = param.value();
    if(param.type() != HttpParameterType.URL) continue;

    if(paramRegex.matcher(value).find()) {
        var start = "(?:^|[^\\w'\".])";
        var end = "\\s*[(]";
        var callbackRegex = Pattern.compile(start + Pattern.quote(value) + end);

        if(callbackRegex.matcher(body).find()) {
            return true;
        }
    }
}
return false;

Preguntas Frecuentes (FAQ)

¿En qué lenguaje se escriben las Bambdas?

Las Bambdas se escriben en Java (fragmentos de Java), con una sintaxis muy similar a la de JavaScript u otros lenguajes de estilo C.

¿Necesito Burp Suite Professional para usar Bambdas?

Puedes crear Bambdas para filtros en Burp Suite Community y Professional. Sin embargo, algunas funciones avanzadas (como columnas personalizadas o reglas de Match-and-Replace) están disponibles solo en Professional.

¿En qué se diferencian las Bambdas de las extensiones tradicionales de Burp?

Las extensiones tradicionales se desarrollan con la API de Burp (Montoya o Extender) y requieren un entorno de compilación (Maven, Gradle, etc.). Las Bambdas, en cambio, son mini extensiones escritas directamente en la interfaz de Burp Suite, sin necesidad de compilar o usar un IDE externo.

¿Las Bambdas pueden afectar el rendimiento?

Sí. Dado que las Bambdas ejecutan código arbitrario, podrían ralentizar Burp si su lógica es muy pesada. Es recomendable optimizarlas para evitar cuellos de botella.

¿Puedo compartir mis Bambdas?

Sin duda. Las Bambdas se pueden guardar en archivos JSON, compartir y además subir al repositorio oficial de Bambdas de PortSwigger en GitHub para que la comunidad las use.

¿Cómo identifico y resuelvo errores de compilación o ejecución?

El editor de Bambdas en Burp Suite resalta errores de compilación en tiempo real. Si hay errores, debes resolverlos antes de aplicar la Bambda. Los errores de ejecución aparecen como advertencias en la barra de filtros o la interfaz relevante.

¿Puedo cargar una Bambda de una herramienta de Burp en otra?

No. Las Bambdas son específicas de cada herramienta. Por ejemplo, no puedes usar una Bambda de HTTP History en Logger, ya que los objetos y las funcionalidades son distintos.

Recursos y Enlaces

Apple sigue sin parchar la vulnerabilidad de DNS
Subir