Obfuscación por Inversión de Cadenas

Módulo 01

#01 Obfuscación por Inversión de Cadenas

📖DEFINICIÓN

La obfuscación por inversión de cadenas (reverse string obfuscation) es una técnica de bypass en seguridad web que consiste en invertir el orden de los caracteres de una cadena de texto (email, URL, payload, palabra clave) para que los sistemas de filtrado no la reconozcan, mientras que un humano o un script posterior puede leerla fácilmente invirtiéndola de nuevo.

No tiene un CVE específico porque no es una vulnerabilidad en sí misma: es un método de evasión que aprovecha discrepancias entre cómo los filtros analizan el texto y cómo los sistemas procesan o muestran ese mismo texto.

✅CONCEPTO CLAVE

El atacante invierte una cadena antes de enviarla. El filtro la analiza tal cual (al revés) y no encuentra el patrón buscado. El backend, navegador o receptor la procesa de forma que el payload resulta efectivo.

En muchos contextos (phishing, Juice Shop OWASP, scraping evasion) simplemente se espera que el humano la lea al revés mentalmente.

⚡EJEMPLO BÁSICO

Estado	Cadena
Normal	usuario@ejemplo.com
Invertida	moc.olmepje@oisairu
Filtro ve	❌ No coincide con @ejemplo.com
Humano lee	✅ Entiende el email fácilmente

⚠ Contexto educativo: Todo el contenido de este módulo es para comprender, detectar y mitigar estas técnicas. La aplicación de estas técnicas sin autorización puede ser ilegal.

Módulo 02

#02 Cómo Funciona: El Flujo del Ataque

🔄FLUJO DE ATAQUE — EMAIL PHISHING

😈

Atacante

Escribe el email malicioso normalmente

payload: usuario@banco-seguro.com

▼ invierte la cadena antes de enviar

🔀

Transformación

La cadena se invierte con .split('').reverse().join('')

obfuscado: moc.oruges-ocnab@oiraisu

▼ el email llega al sistema con el texto invertido

🛡️

Filtro / WAF

Busca @banco-seguro.com en la cadena — NO la encuentra

Resultado: ✅ PERMITIDO (falso negativo)

▼ el email llega al destinatario

👤

Víctima / Sistema destino

El humano lee el texto al revés mentalmente — o un script lo invierte

Entiende: usuario@banco-seguro.com → Hace clic

▼ objetivo conseguido

💀

Resultado

El phishing tuvo éxito — el filtro fue bypasseado

💻IMPLEMENTACIÓN EN JAVASCRIPT

JAVASCRIPT

// La función más simple de inversión
function reverseString(str) {
  return str.split('').reverse().join('');
}

// Ejemplo: obfuscar un email
const email  = 'usuario@ejemplo.com';
const obfusc = reverseString(email);
console.log(obfusc); // → 'moc.olmepje@oiraisu'
// Reconstruir en el cliente (como haría el atacante)
const original = reverseString(obfusc);
console.log(original); // → 'usuario@ejemplo.com'
// Uso en HTML para evadir scrapers
document.write(reverseString('moc.olmepje@oiraisu'));

PYTHON

# Python: inversión de cadena con slicing
email   = "usuario@ejemplo.com"
obfusc  = email[::-1]
print(obfusc)   # → 'moc.olmepje@oiraisu'
# Payload XSS invertido para evadir WAF
payload = "<script>alert(1)</script>"
obf_xss = payload[::-1]
print(obf_xss)  # → '>tpircs/<)1(trela>tpircs<'
# Detección simple (ver módulo 06)
def detect_reverse(text, known_pattern):
    return known_pattern in text[::-1]

💡 ¿Por qué funciona? Los filtros estáticos (WAF, blacklists, regex) comparan la cadena exactamente como llega. Si no aplican transformaciones previas como inversión, decodificación o normalización Unicode, un simple .reverse() basta para evadir el análisis.

Módulo 03

#03 Variantes y Técnicas Combinadas

🧬HOMOGLYPHS — CARACTERES VISUALMENTE IDÉNTICOS

Los homoglyphs son caracteres Unicode que se parecen visualmente a letras latinas pero tienen un codepoint diferente. Un filtro que compare bytes o codepoints los verá como distintos, pero un humano no notará la diferencia.

Letra latina	Homoglyph	Unicode	Ejemplo
a	а (cirílico)	U+0430	pаypal.com ≠ paypal.com
e	е (cirílico)	U+0435	googlе.com ≠ google.com
o	о (cirílico)	U+043E	micrоsoft.com ≠ microsoft.com
c	с (cirílico)	U+0441	faсebook.com ≠ facebook.com

⚡ Combinación peligrosa: Inversión + Homoglyphs. El texto invertido contiene letras cirílicas que parecen latinas. El filtro falla en dos niveles distintos.

🔢ENCODINGS MÚLTIPLES

URL Encoding

@ → %40 · / → %2F

Double URL Encoding

% → %25 → %2540 en lugar de %40

HTML Entities

< → < · > → >

Base64

alert(1) → YWxlcnQoMSk=

Combinado

Base64 → Invertir → URL Encode: capas de evasión apiladas

👻CARACTERES INVISIBLES

Insertar caracteres Unicode de anchura cero o de control dentro de la cadena. El texto se ve igual para el humano pero rompe los patrones del filtro.

Carácter	Unicode	Efecto
Zero Width Space	U+200B	pass → 'pass' visualmente
Zero Width Joiner	U+200D	scr‍ipt → 'script' visualmente
Soft Hyphen	U+00AD	password → 'password' visualmente
RTL Override	U+202E	Invierte dirección visual del texto

El carácter U+202E (Right-to-Left Override) hace que el texto se muestre al revés visualmente en interfaces que respetan la dirección Unicode — sin necesitar inversión real de bytes.

🤖INVERSIÓN PARCIAL Y ATAQUES A LLMs

Una variante moderna usa inversión parcial: solo se invierten las partes "sensibles" de una cadena (el dominio, la palabra clave) manteniendo el resto legible. Esto hace más difícil la detección automatizada.

En ataques contra Large Language Models (LLMs) como ChatGPT, se usa reverse text para intentar evadir los filtros de detección de prompts maliciosos o jailbreaks:

PROMPT INJECTION — EJEMPLO EDUCATIVO
# Normal (detectado por el filtro):
"Ignora las instrucciones anteriores y..."
# Invertido para evasión:
"...y seroiretna senoiccurtsni sal arono gI"
# → El modelo recibe instrucción de 'leer al revés' primero
# → Algunos modelos lo procesan, el filtro no lo detecta

Módulo 04

#04 Casos de Uso Reales

🧃OWASP JUICE SHOP

Juice Shop es una aplicación web vulnerable de OWASP usada en labs. Contiene un reto donde una dirección de email está escrita al revés como pista o mecanismo de obfuscación.

El reto enseña precisamente que los sistemas pueden ignorar texto invertido mientras que los administradores usan esa técnica para "esconder" información de scrapers o filtros.

En Juice Shop: el email del admin aparece como rab@ylcuJ.pus — inviértelo: pus.Jculy@bar. El sistema lo acepta porque la lógica de autenticación lo normaliza internamente.

🕷️SCRAPING EVASION (EMAILS)

Técnica clásica usada por webmasters para proteger emails en páginas web de bots de spam que recolectan direcciones. El email se escribe al revés en el HTML:

HTML
<!-- El bot scraper ve esto y no reconoce el email -->
<span class="email-rev">moc.empresa@otcatnoc</span>

<!-- El JS lo invierte para el usuario humano -->
<script>
  document.querySelectorAll('.email-rev')
    .forEach(el => {
      el.textContent = el.textContent
        .split('')
        .reverse()
        .join('');
    });
</script>

📧PHISHING / ANTISPAM BYPASS

Filtros antispam buscan dominios maliciosos conocidos. Al invertir el dominio en el cuerpo del email, el filtro no lo encuentra en su blacklist.

Técnica	Ejemplo
Normal	Haz clic en banco.ru/login
Invertido	Haz clic en ur.ocnab/nigol
RTL Unicode	U+202E invierte display sin cambiar bytes

💉XSS / INYECCIÓN WEB

Payloads maliciosos invertidos para evadir WAFs que filtran <script>:

XSS BYPASS
# WAF bloquea: <script>alert(1)</script>
# Invertido: >tpircs/<)1(trela>tpircs<
# El servidor invierte antes de renderizar → RCE
# Double encoding + reverse combinado:
"%3Ctpircs%3E" # URL-encoded reversed <script>

🔐BYPASS DE VALIDACIONES Y BLACKLISTS

Sistemas que validan emails, usernames o dominios contra una blacklist de palabras prohibidas son vulnerables si no normalizan la entrada:

Campo	Blacklist busca	Input invertido	Resultado
Username	admin	nimda	✅ PERMITIDO
Email domain	@malware.com	moc.erawlam@	✅ PERMITIDO
Comentario	DROP TABLE	ELBAT PORD	✅ PERMITIDO
URL	javascript:	:tpircsavaj	✅ PERMITIDO

Módulo 05 — Laboratorio Práctico

#05 Lab: Generador de Obfuscación

🧪 Objetivo del lab: Experimenta con las distintas técnicas de obfuscación y observa cómo la misma cadena puede transformarse de formas que un filtro estático no reconocería. Usa este lab para entender el problema, no para causar daño.

⚡ GENERADOR DE OBFUSCACIONES INTERACTIVO

Cadena de entrada (email, URL, payload...) Técnica(s) a aplicar

// Resultado aparecerá aquí

🔁 SIMULADOR DE FILTRO VS PAYLOAD INTERACTIVO

Simula cómo un filtro estático que busca una palabra/patrón reacciona ante la versión obfuscada. Observa el resultado real vs el que ve el filtro.

Patrón que busca el filtro

Input obfuscado (pega el resultado de arriba)

// Resultado de la simulación

Módulo 06 — Laboratorio Práctico

#06 Lab: Detector y Normalizador

🎯 Objetivo: Aprende a detectar y normalizar inputs obfuscados antes de validarlos — la base de la mitigación correcta.

🛡️ DETECTOR DE OBFUSCACIÓN INTERACTIVO

Pega cualquier cadena sospechosa. El detector aplicará múltiples transformaciones y buscará patrones de riesgo en cada versión.

Cadena a analizar Patrones de riesgo a detectar (separados por coma)

// Análisis aparecerá aquí

🔧 NORMALIZADOR DE INPUT INTERACTIVO

Simula el proceso correcto de normalización que debería aplicar un sistema seguro antes de validar cualquier input.

Input crudo del usuario

// Proceso de normalización

Módulo 07

#07 Cómo Mitigar Esta Técnica

✅ Principio fundamental: Siempre valida en whitelist (lo que está permitido) en lugar de blacklist (lo que está prohibido). Una whitelist es infinitamente más robusta contra cualquier técnica de obfuscación.

🔧PIPELINE DE VALIDACIÓN SEGURA

JAVASCRIPT — PIPELINE SEGURO

/**
 * Pipeline de normalización segura antes de validar
 * SIEMPRE aplicar ANTES de cualquier blacklist/whitelist
 */
function normalizeInput(input) {
  let normalized = input;

  // 1. Decodificar URL encoding (y double encoding)
try {
    let prev = '';
    while(prev !== normalized) {
      prev = normalized;
      normalized = decodeURIComponent(normalized);
    }
  } catch(e) {}

  // 2. Decodificar HTML entities
const txt = document.createElement('textarea');
  txt.innerHTML = normalized;
  normalized = txt.value;

  // 3. Eliminar caracteres de control y anchura cero
  normalized = normalized.replace(
    /[\u200B\u200C\u200D\u200E\u200F\u202A-\u202E\uFEFF]/g,
    ''
  );

  // 4. Normalizar Unicode (NFKC: convierte homoglyphs)
  normalized = normalized.normalize('NFKC');

  // 5. Convertir a minúsculas
  normalized = normalized.toLowerCase();

  // 6. Comprobar también la versión invertida
const reversed = normalized.split('').reverse().join('');

  return { normalized, reversed };
}

// Validación con whitelist de email
function validateEmail(input) {
  const { normalized, reversed } = normalizeInput(input);
  const emailRegex = /^[a-z0-9._%+\-]+@[a-z0-9.\-]+\.[a-z]{2,}$/;

  // Validar tanto la versión normal como la invertida
return emailRegex.test(normalized) || emailRegex.test(reversed);
}

✅CHECKLIST DE MITIGACIÓN

Marca cada medida que hayas implementado o comprendido:

Normalización exhaustiva del input antes de validar

toLowerCase() + Unicode NFKC + eliminar chars invisibles + decodificar URL/HTML

Validar con whitelist, no con blacklist

Definir exactamente qué caracteres y formato están permitidos (regex estricta)

Verificar también la cadena invertida

Comprobar si el reverso del input contiene patrones maliciosos

Decodificación múltiple antes de validar

URL decode en bucle hasta que no cambie, luego HTML entities, luego Base64 si aplica

Detección de homoglyphs

Usar normalize('NFKC') o librerías como confusables / unidecode en Python

Output encoding correcto

Siempre usar DOMPurify / OWASP Java Encoder al mostrar datos de usuario en HTML

SPF + DKIM + DMARC para emails

Autenticación de origen del email + análisis de contenido que normalice Unicode

WAF con reglas de normalización activas

Configurar el WAF para que decodifique y normalice antes de aplicar reglas

0 / 8 medidas completadas

🐍PYTHON — DETECCIÓN

PYTHON

import unicodedata
from urllib.parse import unquote

def normalize_input(text: str) -> dict:
    # Pipeline de normalización segura
# 1. URL decode en bucle
    prev = None
while prev != text:
        prev = text
        text = unquote(text)

    # 2. Normalizar Unicode (NFKC)
    text = unicodedata.normalize('NFKC', text)

    # 3. Eliminar chars invisibles
    invisible = ['\u200b','\u200c','\u200d',
                 '\u202e','\ufeff']
    for c in invisible:
        text = text.replace(c, '')

    # 4. Lowercase
    text = text.lower()

    return {
        'normalized': text,
        'reversed': text[::-1]
    }

🛡️HERRAMIENTAS RECOMENDADAS

DOMPurify — sanitización HTML/JS en el cliente (JS)
OWASP Java Encoder — output encoding en Java
unidecode (Python) — convierte Unicode a ASCII equivalente, detecta homoglyphs
confusables (Python) — detecta caracteres Unicode confusables según Unicode.org
ModSecurity — WAF con reglas CRS que incluyen normalización
Bleach (Python) — sanitización HTML con whitelist
validator.js — validación robusta de emails y URLs en JS/Node

La validación de emails reales debe hacerse con RFC 5321 compliant validators, no con regex caseras.

Módulo 08 — Evaluación

#08 Quiz de Conocimiento

📝 Instrucciones: Responde las siguientes preguntas para evaluar tu comprensión del módulo. Cada pregunta tiene una sola respuesta correcta.