Impossible de poser des breakpoints avec gdb

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:

---

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:

---

gcc -ggdb -g3 test.c -o test

---

et voilà le code de test.c :

Code:

---

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 :)

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

Code:

---

gdb ./test

---

dans gdb :

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

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

---

Bonjour,

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

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..

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:

---

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:

---

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.

Citation:

---

Envoyé par 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.

---

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

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:

---

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

Citation:

---

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 .