Discussion :

[awesomeman]

Bonjour,

Je m’entraîne en ce moment à utiliser gdb . D'habitude j'utilise directement des exécutables sans le code source .
Mais la j’essaye de faire un simple programme pour tester avec mon propre code .
Problème, lorsque je tente de poser un breakpoint j'obtiens un warning :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Warning:
Cannot insert breakpoint 1.
Cannot access memory at address 0x704

Je suppose que je dois utiliser des flags de compil ou autre mais je ne trouve ..

voilà comment je compile :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

gcc -ggdb -g3 test.c -o test

et voilà le code de test.c :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#include "stdio.h"
 
int main()
{
  int a = 42;
  int b = 84;
 
  if (a < b)
    {
      printf("test");
    }
  return 0;
}

Merci d'avance pour votre aide

[Matt_Houston]

Comment invoques-tu gdb ? Quelle(s) commande(s) entres-tu ?

[awesomeman]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

gdb ./test

dans gdb :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
gdb-peda$ disas main
Dump of assembler code for function main:
   0x000000000000064a <+0>:	push   rbp
   0x000000000000064b <+1>:	mov    rbp,rsp
   0x000000000000064e <+4>:	sub    rsp,0x10
   0x0000000000000652 <+8>:	mov    DWORD PTR [rbp-0x8],0x2a
   0x0000000000000659 <+15>:	mov    DWORD PTR [rbp-0x4],0x54
   0x0000000000000660 <+22>:	mov    eax,DWORD PTR [rbp-0x8]
   0x0000000000000663 <+25>:	cmp    eax,DWORD PTR [rbp-0x4]
   0x0000000000000666 <+28>:	jge    0x679 <main+47>
   0x0000000000000668 <+30>:	lea    rdi,[rip+0x95]        # 0x704
   0x000000000000066f <+37>:	mov    eax,0x0
   0x0000000000000674 <+42>:	call   0x530 <printf@plt>
   0x0000000000000679 <+47>:	mov    eax,0x0
   0x000000000000067e <+52>:	leave  
   0x000000000000067f <+53>:	ret    
End of assembler dump.
gdb-peda$ b * 0x674
Breakpoint 1 at 0x674: file test.c, line 10.
gdb-peda$ r
Starting program: /home/f-society/prog/secu/crack/test 
Warning:
Cannot insert breakpoint 1.
Cannot access memory at address 0x674

[LittleWhite]

Bonjour,

Que fait l'option -g3 ?
Moi, généralement, je ne mets que l'option -g et tout roule pour le débogage.

[Matt_Houston]

Je suis parvenu à reproduire ce comportement avec le programme fourni. Je ne comprends pas non plus ce qui se passe et honnêtement je n'utilise jamais directement les adresses brutes pour le débug.

Il est intéressant de noter que placer le breakpoint avec la notation : (gdb) b *main+42 fonctionne parfaitement..

[sambia39]

Bonjour,
Dans un premier temps, il faut savoir que vous utilisez GDB avec une extension PEDA donc une utilisation conjointe de deux outils. De plus, l’extension PEDA ajoute des commandes en plus des commandes de base de GDB et vue la sortie de vos commandes sur écrans vous souhaiter mettre un break point non pas sur une fonction qui est celle de printf, mais sur l’adresse probable de l’appel de printf . Alors pourquoi elle échoue :
La raison la plus évidente et qui est sous vos yeux est que l’adresse a accédé n'est pas nappée donc forcement derrière cela échoue systématiquement et ceux parce que l’adresse ne permet pas à GDB et son extension de le mapper en mémoire. Autre raison peut venir de l'outils lui-même ou a cause d'une mauvaise adresse.
En clair, les breaks pointe sont mal placer exemple ci-dessous (donc soit l'outil utilise peda, c'est le cas donc faut voir comment il mappe la chose et pourquoi il pointe autre et non sur l'adresse souhaitée; Soit c'est une erreur humaine tout simplement)

Code GDB :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
disass main
Dump of assembler code for function main:
   0x0000000000400526 <+0>:	push   rbp
   0x0000000000400527 <+1>:	mov    rbp,rsp
   0x000000000040052a <+4>:	sub    rsp,0x10
   0x000000000040052e <+8>:	mov    DWORD PTR [rbp-0x8],0x2a
   0x0000000000400535 <+15>:	mov    DWORD PTR [rbp-0x4],0x54
   0x000000000040053c <+22>:	mov    eax,DWORD PTR [rbp-0x8]
   0x000000000040053f <+25>:	cmp    eax,DWORD PTR [rbp-0x4]
   0x0000000000400542 <+28>:	jge    0x400553 <main+45>
   0x0000000000400544 <+30>:	mov    edi,0x4005e4
   0x0000000000400549 <+35>:	mov    eax,0x0
   0x000000000040054e <+40>:	call   0x400400 <printf@plt>
   0x0000000000400553 <+45>:	mov    eax,0x0
   0x0000000000400558 <+50>:	leave  
   0x0000000000400559 <+51>:	ret   
End of assembler dump.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
(gdb) b *0x040054e
Breakpoint 1 at 0x40054e: file source.c, line 10.
(gdb) r
Starting program: /Gcc/Deb 

Breakpoint 1, 0x000000000040054e in main () at source.c:10
10	        printf("test");
(gdb) b *040054e
Breakpoint 2 at 0x9c76
(gdb) r
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /Gcc/Deb 
Warning:
Cannot insert breakpoint 2.
Cannot access memory at address 0x9c76
(gdb)

En dehors de l’erreur précédente, l’erreur peut également venir du fait que la bibliothèque ou se trouve printf n’est pas charger (mappée), car vous déboguer juste l’exécutable et non l’exécutable et les bibliothèques qui lui sont associées et en attendant vous pouvez utiliser la commande b start, mais attention elle peut échouer, si main n’existe pas ou n’est pas définie voir parcequ’il n’y a pas d’information symbolique de débogage donc compilé sans option. Une façon indirecte qui est une autre solution; mais pas très catholique est de mettre un point d’arrêt sur l’adresse 0x0 ce qui permet ou force GDB à pointer ou fournir le point d’entrer de l’application et par la suite mettre un break pointe sur cette adresse et step by step, on scrute.

Et comme ce que j'ai mentionnent en premier l'erreur possible peut venir GDB lui-même, c’est-à-dire qu’il n’est pas en mesure de mapper la mémoire tout cours ou impossible qu’il accède à une mémoire spécifique et donc l’accès à cette adresse ne peut être réalisé et donc elle échoue. Une façon plus catholique serait tout simplement de mettre le point d’arrêt sur la ligne ou se trouve la fonction en question b 10 (pour vous ligne 10 donc celle de printf) et par la suite step by step, on peut commencer à déboguer et accéder à la mémoire avec les diverses commandes.

Faut également se poser la question légitime de ce dire si l'outil GDB ne suffit pas lui-même pour l'examen d'un tel programme (attention, je ne critique pas votre travail, mais je mets l'accent sur le choix d'un outil adapter à un examen) car l'utiliser l'extension PEDA avec, c'est pour une investigation poussez et maîtriser. Et en vue du code elle mérite pas un tel prestige, mais bon, c'est une question de choix et de goût GDB suffirais à faire le travail.

Bonjour,

Que fait l'option -g3 ?
Moi, généralement, je ne mets que l'option -g et tout roule pour le débogage.

Cela existe bel et bien, c’est ce que l’on appelle un gvmslevel qui demander au compilateur de d’inclure des informations de débogage selon les niveaux souhaiter . Le niveau par défaut est 2 donc -g2 ou -g (tout court normalement). Le niveau 3 soit g3 incluent juste des informations sur les définitions de macros, présentes dans l’exécutable. Et le niveau 0 ne génère aucune information de débogage quant au niveau 1, c’est le strict minimum.

Autre information importe sur la documentation de GCC est qu’au sujet de g2 où g la chose est floue concernant ce qui est inclus donc… faut faire confience.

À bientôt

[awesomeman]

Merci à tous pour vos réponses, ducoup je me suis rabattue sur la syntaxe main+...

En fait, les adresses fournit par gdb (ou plutot peda) ne sont tout simplement pas les bonnes ..

voilà ce que je fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
32
33
34
35
36
37
38
39
40
gdb-peda$ disas main
Dump of assembler code for function main:
   0x000000000000072a <+0>:	push   rbp
   0x000000000000072b <+1>:	mov    rbp,rsp
   0x000000000000072e <+4>:	sub    rsp,0x20
   0x0000000000000732 <+8>:	mov    DWORD PTR [rbp-0x18],0x17
   0x0000000000000739 <+15>:	mov    DWORD PTR [rbp-0x14],0x1
 .........................
   0x00000000000007a8 <+126>:	call   0x600 <printf@plt>
   0x00000000000007ad <+131>:	mov    rax,QWORD PTR [rbp-0x10]
   0x00000000000007b1 <+135>:	mov    rdi,rax
   0x00000000000007b4 <+138>:	call   0x5e0 <free@plt>
   0x00000000000007b9 <+143>:	mov    eax,0x0
   0x00000000000007be <+148>:	leave  
   0x00000000000007bf <+149>:	ret    
End of assembler dump.
gdb-peda$ b * 0x0
Breakpoint 1 at 0x0
gdb-peda$ r
Starting program: /home/fumery/prog/secu/crack/a.out 
Warning:
Cannot insert breakpoint 1.
Cannot access memory at address 0x0
 
gdb-peda$ disas main
Dump of assembler code for function main:
   0x000055555555472a <+0>:	push   rbp
   0x000055555555472b <+1>:	mov    rbp,rsp
   0x000055555555472e <+4>:	sub    rsp,0x20
   0x0000555555554732 <+8>:	mov    DWORD PTR [rbp-0x18],0x17
   0x0000555555554739 <+15>:	mov    DWORD PTR [rbp-0x14],0x1
  ................................................................
   0x00005555555547a8 <+126>:	call   0x555555554600 <printf@plt>
   0x00005555555547ad <+131>:	mov    rax,QWORD PTR [rbp-0x10]
   0x00005555555547b1 <+135>:	mov    rdi,rax
   0x00005555555547b4 <+138>:	call   0x5555555545e0 <free@plt>
   0x00005555555547b9 <+143>:	mov    eax,0x0
   0x00005555555547be <+148>:	leave  
   0x00005555555547bf <+149>:	ret    
End of assembler dump.

après avoir mis un 0x0, on retrouve les bonnes adresses avec disas main

Faut également se poser la question légitime de ce dire si l'outil GDB ne suffit pas lui-même pour l'examen d'un tel programme (attention, je ne critique pas votre travail, mais je mets l'accent sur le choix d'un outil adapter à un examen) car l'utiliser l'extension PEDA avec, c'est pour une investigation poussez et maîtriser. Et en vue du code elle mérite pas un tel prestige, mais bon, c'est une question de choix et de goût GDB suffirais à faire le travail.

C'est vrai qu'ici peda est absolument inutile gdb suffit amplement. la plupart du temps je travaille sur du code beaucoup plus conséquent et plus dur à appréhender, d'ou mon utilisation de peda . De plus lorsque je lance gdb, peda est automatiquement greffé avec gdbinit donc autant utiliser peda à chaque fois plutot que de changer le gdbinit à chaque fois .