GDB disas et ASM

Version imprimable

GDB disas et ASM

Bonjour à tous, je suis en train de faire un projet sécu pour l'école, et j'ai une petite difficulté à reproduire exactement le même comportement que le binaire de base.

Voici la fonction qui me pose problème :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   0x080484d4 <+0>:	push   ebp
   0x080484d5 <+1>:	mov    ebp,esp
   0x080484d7 <+3>:	sub    esp,0x68
   0x080484da <+6>:	mov    eax,ds:0x8049860
   0x080484df <+11>:	mov    DWORD PTR [esp],eax
   0x080484e2 <+14>:	call   0x80483b0 <fflush@plt>
   0x080484e7 <+19>:	lea    eax,[ebp-0x4c]
   0x080484ea <+22>:	mov    DWORD PTR [esp],eax
   0x080484ed <+25>:	call   0x80483c0 <gets@plt>
   0x080484f2 <+30>:	mov    eax,DWORD PTR [ebp+0x4]
   0x080484f5 <+33>:	mov    DWORD PTR [ebp-0xc],eax
   0x080484f8 <+36>:	mov    eax,DWORD PTR [ebp-0xc]
   0x080484fb <+39>:	and    eax,0xb0000000
   0x08048500 <+44>:	cmp    eax,0xb0000000
   0x08048505 <+49>:	jne    0x8048527 <p+83>
   0x08048507 <+51>:	mov    eax,0x8048620
   0x0804850c <+56>:	mov    edx,DWORD PTR [ebp-0xc]
   0x0804850f <+59>:	mov    DWORD PTR [esp+0x4],edx
   0x08048513 <+63>:	mov    DWORD PTR [esp],eax
   0x08048516 <+66>:	call   0x80483a0 <printf@plt>
   0x0804851b <+71>:	mov    DWORD PTR [esp],0x1
   0x08048522 <+78>:	call   0x80483d0 <_exit@plt>
   0x08048527 <+83>:	lea    eax,[ebp-0x4c]
   0x0804852a <+86>:	mov    DWORD PTR [esp],eax
   0x0804852d <+89>:	call   0x80483f0 <puts@plt>
   0x08048532 <+94>:	lea    eax,[ebp-0x4c]
   0x08048535 <+97>:	mov    DWORD PTR [esp],eax
   0x08048538 <+100>:	call   0x80483e0 <strdup@plt>
   0x0804853d <+105>:	leave
   0x0804853e <+106>:	ret

J'ai un probleme avec la ligne p+30. Dans mon code elle n'y est pas.

Voici mon code c :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//gcc -fno-stack-protector -z execstack -Wl,-z,norelro source.c
 
void				p(void)
{
	char			str[0x40];
	char			*ptr;
 
	fflush(stdin);
	ptr = gets(str);
	if (((unsigned int)ptr & 0xb0000000) == 0xb0000000)
	{
		printf("(%p)\n", ptr);
		exit(0x1);
	}
	puts(str);
	strdup(str);
}
 
int				main(void)
{
	p();
}

Je n'arrive pas à comprendre correctement ce qui se passe ligne p+30 a p+33...

Pouvez-vous me donner un coup de main svp :) ?

Pour info, voici mon résultat quand je désassemble ma fonction p :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
   0x080484d4 <+0>:	push   ebp
   0x080484d5 <+1>:	mov    ebp,esp
   0x080484d7 <+3>:	sub    esp,0x68
   0x080484da <+6>:	mov    eax,ds:0x804985c
   0x080484df <+11>:	mov    DWORD PTR [esp],eax
   0x080484e2 <+14>:	call   0x80483b0 <fflush@plt>
   0x080484e7 <+19>:	lea    eax,[ebp-0x4c]
   0x080484ea <+22>:	mov    DWORD PTR [esp],eax
   0x080484ed <+25>:	call   0x80483c0 <gets@plt>
   0x080484f2 <+30>:	mov    DWORD PTR [ebp-0xc],eax
   0x080484f5 <+33>:	mov    eax,DWORD PTR [ebp-0xc]
   0x080484f8 <+36>:	and    eax,0xb0000000
   0x080484fd <+41>:	cmp    eax,0xb0000000
   0x08048502 <+46>:	jne    0x8048524 <p+80>
   0x08048504 <+48>:	mov    eax,0x8048620
   0x08048509 <+53>:	mov    edx,DWORD PTR [ebp-0xc]
   0x0804850c <+56>:	mov    DWORD PTR [esp+0x4],edx
   0x08048510 <+60>:	mov    DWORD PTR [esp],eax
   0x08048513 <+63>:	call   0x80483a0 <printf@plt>
   0x08048518 <+68>:	mov    DWORD PTR [esp],0x1
   0x0804851f <+75>:	call   0x8048400 <exit@plt>
   0x08048524 <+80>:	lea    eax,[ebp-0x4c]
   0x08048527 <+83>:	mov    DWORD PTR [esp],eax
   0x0804852a <+86>:	call   0x80483e0 <puts@plt>
   0x0804852f <+91>:	lea    eax,[ebp-0x4c]
   0x08048532 <+94>:	mov    DWORD PTR [esp],eax
   0x08048535 <+97>:	call   0x80483d0 <strdup@plt>
   0x0804853a <+102>:	leave
   0x0804853b <+103>:	ret

Merci beaucoup :)

Enfin un post assez complet pour qu'on puisse t'aider sans qu'on te pose trop de questions. \o/

Donc si j'ai bien compris, la différence que tu souhaite réduire est :

L'original :
Code:

1 2 3 4 5 6 7 8 9 0x080484e7 <+19>: lea eax,[ebp-0x4c] 0x080484ea <+22>: mov DWORD PTR [esp],eax 0x080484ed <+25>: call 0x80483c0 <gets@plt> 0x080484f2 <+30>: mov eax,DWORD PTR [ebp+0x4] 0x080484f5 <+33>: mov DWORD PTR [ebp-0xc],eax 0x080484f8 <+36>: mov eax,DWORD PTR [ebp-0xc] 0x080484fb <+39>: and eax,0xb0000000 0x08048500 <+44>: cmp eax,0xb0000000
le tien :
Code:

1 2 3 4 5 6 7 8 0x080484e7 <+19>: lea eax,[ebp-0x4c] 0x080484ea <+22>: mov DWORD PTR [esp],eax 0x080484ed <+25>: call 0x80483c0 <gets@plt> 0x080484f2 <+30>: mov DWORD PTR [ebp-0xc],eax 0x080484f5 <+33>: mov eax,DWORD PTR [ebp-0xc] 0x080484f8 <+36>: and eax,0xb0000000 0x080484fd <+41>: cmp eax,0xb0000000
Alors perso je m'amuse rarement à savoir comment le compilo fonctionne (traduire par que je peux dire une connerie dans mon explication), mais j'ai divisé ce bout de code avec la partie haute correspondant à ptr = gets(str);et la partie basse à : if (((unsigned int)ptr & 0xb0000000) == 0xb0000000)
Le truc qu'il fait en plus est : 0x080484f2 <+30>: mov eax,DWORD PTR [ebp+0x4] et apres il y a mov DWORD PTR [ebp-0xc],eax (et deux codes qui se suivent comme ça ressemble à une copie mémoire/mémoire :mrgreen: )
Bon si je me trompe pas eax est la valeur de retour de gets, donc le code original ne devait pas récupérer gets tout simplement (vu que eax est écrasé par une variable sur la pile).
Ca ressemblerait plus a un truc comme ça :
Code:

1 2 3 gets(str); ptr = ptr2;

Merci pour ta réponse Kannagi,

J'avais bien pensé faire un truc comme ça, mais maintenant j'ai une variable de trop (je pense car dans la stack, car il y a un décalage dans l'offset de esp ligne p+30 jusqu'à la fin du code). J'ai essayé avec des adresses de fonction genre fflush, gets... mais ce n'est toujours pas ça... :aie:
Ce qui est bizzare, c'est que c'est $ebp+4 donc pas une variable de la fonction on dirait (je me trompe peut-être :oops:) mais p ne reçoit pas de param :

Citation:

[----------------------------------registers-----------------------------------]
EAX: 0x1
EBX: 0xb7fd0ff4 --> 0x1a4d7c
ECX: 0xbffff7b4 --> 0xbffff8dc ("/home/user/level2/level2")
EDX: 0xbffff744 --> 0xb7fd0ff4 --> 0x1a4d7c
ESI: 0x0
EDI: 0x0
EBP: 0xbffff718 --> 0x0
ESP: 0xbffff710 --> 0x8048550 (<__libc_csu_init>: push ebp)
EIP: 0x8048545 (<main+6>: call 0x80484d4 <p>)
EFLAGS: 0x200282 (carry parity adjust zero SIGN trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x804853f <main>: push ebp
0x8048540 <main+1>: mov ebp,esp
0x8048542 <main+3>: and esp,0xfffffff0
=> 0x8048545 <main+6>: call 0x80484d4 <p>
0x804854a <main+11>: leave
0x804854b <main+12>: ret
0x804854c: nop
0x804854d: nop
Guessed arguments:
arg[0]: 0x8048550 (<__libc_csu_init>: push ebp)
[------------------------------------stack-------------------------------------]
0000| 0xbffff710 --> 0x8048550 (<__libc_csu_init>: push ebp)
0004| 0xbffff714 --> 0x0
0008| 0xbffff718 --> 0x0
0012| 0xbffff71c --> 0xb7e454d3 (<__libc_start_main+243>: mov DWORD PTR [esp],eax)
0016| 0xbffff720 --> 0x1
0020| 0xbffff724 --> 0xbffff7b4 --> 0xbffff8dc ("/home/user/level2/level2")
0024| 0xbffff728 --> 0xbffff7bc --> 0xbffff8f5 ("SHELL=/bin/bash")
0028| 0xbffff72c --> 0xb7fdc858 --> 0xb7e2c000 --> 0x464c457f
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value

Breakpoint 1, 0x08048545 in main ()
gdb-peda$ dumpargs
Guessed arguments:
arg[0]: 0x8048550 (<__libc_csu_init>: push ebp)

Voici le résultat avec la modif de Kannagi :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 #include <stdio.h> #include <stdlib.h> #include <string.h> //gcc -fno-stack-protector -z execstack -Wl,-z,norelro source.c void p(void) { char str[0x40]; char *ptr; char *ptr1; fflush(stdin); gets(str); ptr = ptr1; if (((unsigned int)ptr & 0xb0000000) == 0xb0000000) { printf("(%p)\n", ptr); exit(0x1); } puts(str); strdup(str); } int main(void) { p(); }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 0x080484d4 <+0>: push ebp 0x080484d5 <+1>: mov ebp,esp 0x080484d7 <+3>: sub esp,0x68 0x080484da <+6>: mov eax,ds:0x804985c 0x080484df <+11>: mov DWORD PTR [esp],eax 0x080484e2 <+14>: call 0x80483b0 <fflush@plt> 0x080484e7 <+19>: lea eax,[ebp-0x50] 0x080484ea <+22>: mov DWORD PTR [esp],eax 0x080484ed <+25>: call 0x80483c0 <gets@plt> 0x080484f2 <+30>: mov eax,DWORD PTR [ebp-0xc] 0x080484f5 <+33>: mov DWORD PTR [ebp-0x10],eax 0x080484f8 <+36>: mov eax,DWORD PTR [ebp-0x10] 0x080484fb <+39>: and eax,0xb0000000 0x08048500 <+44>: cmp eax,0xb0000000 0x08048505 <+49>: jne 0x8048527 <p+83> 0x08048507 <+51>: mov eax,0x8048620 0x0804850c <+56>: mov edx,DWORD PTR [ebp-0x10] 0x0804850f <+59>: mov DWORD PTR [esp+0x4],edx 0x08048513 <+63>: mov DWORD PTR [esp],eax 0x08048516 <+66>: call 0x80483a0 <printf@plt> 0x0804851b <+71>: mov DWORD PTR [esp],0x1 0x08048522 <+78>: call 0x8048400 <exit@plt> 0x08048527 <+83>: lea eax,[ebp-0x50] 0x0804852a <+86>: mov DWORD PTR [esp],eax 0x0804852d <+89>: call 0x80483e0 <puts@plt> 0x08048532 <+94>: lea eax,[ebp-0x50] 0x08048535 <+97>: mov DWORD PTR [esp],eax 0x08048538 <+100>: call 0x80483d0 <strdup@plt> 0x0804853d <+105>: leave 0x0804853e <+106>: ret
Pour info, ce programme est compilé sur un Linux 32 bits sans l'aslr et avec les mêmes sécurités (voir flags de compilation).

J'ai capté un truc c'est +4, donc oui ça a été déplié avant que la fonction soit appellée. ;)

Avec ce code tu as un truc plus ressemblant je pense !

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//gcc -fno-stack-protector -z execstack -Wl,-z,norelro source.c
 
void				p(int a)
{
 
	char			*ptr;
	char			str[0x40];
 
 
	fflush(stdin);
 
	gets(str);
	ptr = &a;
	if (((unsigned int)ptr & 0xb0000000) == 0xb0000000)
	{
		printf("(%p)\n", ptr);
		exit(0x1);
	}
	puts(str);
	strdup(str);
}
 
int				main(void)
{
 
	p(2);
}

Ce n'est toujours pas ça, car le & me donnera un lea... et si je passe une adresse en paramètre ça fait 8 octets. :(

Ca fait 2 jours que je suis là-dessus lol, j'ai vraiment testé beaucoup de trucs mdr 8-)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//gcc -fno-stack-protector -z execstack -Wl,-z,norelro source.c
 
void                            p(char *val)
{
        char                    str[0x40];
        void                    *ptr;
 
        fflush(stdin);
        gets(str);
        ptr = val;
        if (((unsigned int)ptr & 0xb0000000) == 0xb0000000)
        {
                printf("(%p)\n", ptr);
                exit(0x1);
        }
        puts(str);
        strdup(str);
}
 
int                             main(int argc, char **argv)
{
        p(argv[0]);
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   0x080484d4 <+0>:	push   ebp
   0x080484d5 <+1>:	mov    ebp,esp
   0x080484d7 <+3>:	sub    esp,0x68
   0x080484da <+6>:	mov    eax,ds:0x804986c
   0x080484df <+11>:	mov    DWORD PTR [esp],eax
   0x080484e2 <+14>:	call   0x80483b0 <fflush@plt>
   0x080484e7 <+19>:	lea    eax,[ebp-0x4c]
   0x080484ea <+22>:	mov    DWORD PTR [esp],eax
   0x080484ed <+25>:	call   0x80483c0 <gets@plt>
   0x080484f2 <+30>:	mov    eax,DWORD PTR [ebp+0x8]
   0x080484f5 <+33>:	mov    DWORD PTR [ebp-0xc],eax
   0x080484f8 <+36>:	mov    eax,DWORD PTR [ebp-0xc]
   0x080484fb <+39>:	and    eax,0xb0000000
   0x08048500 <+44>:	cmp    eax,0xb0000000
   0x08048505 <+49>:	jne    0x8048527 <p+83>
   0x08048507 <+51>:	mov    eax,0x8048630
   0x0804850c <+56>:	mov    edx,DWORD PTR [ebp-0xc]
   0x0804850f <+59>:	mov    DWORD PTR [esp+0x4],edx
   0x08048513 <+63>:	mov    DWORD PTR [esp],eax
   0x08048516 <+66>:	call   0x80483a0 <printf@plt>
   0x0804851b <+71>:	mov    DWORD PTR [esp],0x1
   0x08048522 <+78>:	call   0x8048400 <exit@plt>
   0x08048527 <+83>:	lea    eax,[ebp-0x4c]
   0x0804852a <+86>:	mov    DWORD PTR [esp],eax
   0x0804852d <+89>:	call   0x80483e0 <puts@plt>
   0x08048532 <+94>:	lea    eax,[ebp-0x4c]
   0x08048535 <+97>:	mov    DWORD PTR [esp],eax
   0x08048538 <+100>:	call   0x80483d0 <strdup@plt>
   0x0804853d <+105>:	leave
   0x0804853e <+106>:	ret