Expresiones regulares

Una expresión regular (regex) es un patrón para buscar, extraer o validar texto. En seguridad aparecen en todas partes: filtrar output de herramientas, extraer URLs/emails/hashes de un volcado, escribir reglas de detección (WAF, IDS, grep en logs) y entender —o romper— validaciones de entrada. Dominar regex convierte megabytes de ruido en la línea exacta que buscas.

Sintaxis esencial

.        cualquier carácter        \d  dígito      \w  alfanumérico+_
*        0 o más                   \s  espacio     \b  límite de palabra
+        1 o más                   ^   inicio de línea
?        0 o 1 (opcional)          $   fin de línea
{2,5}    entre 2 y 5 repeticiones  []  clase: [a-z], [0-9], [^abc] (negada)
(...)    grupo de captura          |   alternativa (a|b)
\        escapa un metacarácter    (?:...) grupo sin captura

Patrones útiles en pentest

# emails
[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}
# IPv4
\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b
# URLs
https?://[^\s"'<>]+
# hash MD5 (32 hex)
\b[a-fA-F0-9]{32}\b
# posibles secretos/API keys
(?i)(api[_-]?key|secret|token|password)["'\s:=]+[A-Za-z0-9._-]{8,}

Usarlas en la práctica

# grep extendido: extraer solo lo que coincide (-o)
grep -oE 'https?://[^ "]+' file.txt | sort -u
grep -rE '(?i)password\s*=' .            # buscar credenciales en código
# en Python
import re
re.findall(r"\b[A-Fa-f0-9]{32}\b", texto)   # todos los MD5
re.search(r"id=(\d+)", url).group(1)          # capturar un grupo
# sed con grupos de captura (\1)
sed -E 's/(user)=[^&]+/\1=REDACTED/' log

Greedy vs lazy (un error clásico)

<.*>     # greedy: captura de más (<a> ... </b> entero)
<.*?>    # lazy: captura lo mínimo (cada etiqueta por separado)

El cuantificador “perezoso” (?) evita que .* se trague más de la cuenta — fuente típica de regex rotas.

Por qué importa en seguridad

Extraer IOCs de un log, sacar todos los subdominios de un volcado de recon, encontrar claves hardcodeadas en un repo, escribir una firma de detección, o analizar por qué un WAF bloquea tu payload: todo es regex. Y del otro lado, muchas validaciones de entrada (y filtros de WAF) son regex mal escritas que se pueden evadir —entenderlas es romperlas.

Errores comunes

Olvidar escapar metacaracteres literales (., (, [).
Greedy donde querías lazy.
Regex catastróficamente lentas (ReDoS) con anidamiento de cuantificadores (a+)+.
Validar emails/URLs con regex “perfectas” imposibles — a veces basta con “contiene @ y un punto”.

Checklist de dominio

Conozco metacaracteres, clases, cuantificadores y anclas
Escribo patrones para email, IP, URL y hashes
Uso grep -oE y re.findall/re.search para extraer datos
Capturo y reutilizo grupos (\1, .group(1))
Entiendo greedy vs lazy y cuándo usar cada uno
Reconozco riesgos de ReDoS y validaciones evadibles
Pruebo mis regex en regex101 antes de confiar en ellas