Trouver le mot de passe d'un programme

Dans ce tutoriel, je vais rester très simple pour comprendre rapidement comme on peut arriver à nos fin. Cependant, la notion du langage C est prérequis car je ne vais pas expliquer en détail le code ci-dessous.

Admettons que nous avons ce programme qui demande une authentification pour accéder un contenu secret :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
        char mdp[30];
        printf("Password : ");
 
        scanf("%s", mdp);
 
        if(!strcmp(mdp,"pass")) {
                printf("Bon mot de passe!\n");
                // Contenu secret
        } else {
                printf("Essait encore!\n");
        }
 
    return 0;
}

On compile le programme :

gcc main.c -o programme

Plusieurs outils permettent le contournement.

gdb ./programme
(gdb) break main
(gdb) run
(gdb) disassemble

Dump of assembler code for function main:
   0x00005555555547e0 <+0>:     push   %rbp
   0x00005555555547e1 <+1>:     mov    %rsp,%rbp
=> 0x00005555555547e4 <+4>:     sub    $0x30,%rsp
   0x00005555555547e8 <+8>:     mov    %fs:0x28,%rax
   0x00005555555547f1 <+17>:    mov    %rax,-0x8(%rbp)
   0x00005555555547f5 <+21>:    xor    %eax,%eax
   0x00005555555547f7 <+23>:    lea    0xf6(%rip),%rdi        # 0x5555555548f4
   0x00005555555547fe <+30>:    mov    $0x0,%eax
   0x0000555555554803 <+35>:    callq  0x555555554690
   0x0000555555554808 <+40>:    lea    -0x30(%rbp),%rax
   0x000055555555480c <+44>:    mov    %rax,%rsi
   0x000055555555480f <+47>:    lea    0xea(%rip),%rdi        # 0x555555554900
   0x0000555555554816 <+54>:    mov    $0x0,%eax
   0x000055555555481b <+59>:    callq  0x5555555546a0
   0x0000555555554820 <+64>:    lea    -0x30(%rbp),%rax
   0x0000555555554824 <+68>:    lea    0xd8(%rip),%rsi        # 0x555555554903
   0x000055555555482b <+75>:    mov    %rax,%rdi
   0x000055555555482e <+78>:    callq  0x555555554698
   0x0000555555554833 <+83>:    test   %eax,%eax
   0x0000555555554835 <+85>:    jne    0x555555554845 <main+101>
   0x0000555555554837 <+87>:    lea    0xca(%rip),%rdi        # 0x555555554908
   0x000055555555483e <+94>:    callq  0x555555554680
   0x0000555555554843 <+99>:    jmp    0x555555554851 <main+113>
   0x0000555555554845 <+101>:   lea    0xce(%rip),%rdi        # 0x55555555491a
   0x000055555555484c <+108>:   callq  0x555555554680
   0x0000555555554851 <+113>:   mov    $0x0,%eax
   0x0000555555554856 <+118>:   mov    -0x8(%rbp),%rdx
   0x000055555555485a <+122>:   xor    %fs:0x28,%rdx
   0x0000555555554863 <+131>:   je     0x55555555486a <main+138>
   0x0000555555554865 <+133>:   callq  0x555555554688
   0x000055555555486a <+138>:   leaveq
   0x000055555555486b <+139>:   retq
End of assembler dump.

La sortie nous affiche la suite d'instructions présente dans la fonction main. On remarque qu'il y a un registre jne qui doit sans doute être liée à la conditions pour tester si le mot de passe correspond à celui attendu. Dans la théorie, si l'on inverse la condition alors on pourra accéder à la partie secrète. Alors, il suffit de changer le registre jne (code 0x75) par je (code 0x74) à l'adresse mémoire correspondante. Ainsi :

(gdb) set {char} 0x0000555555554835=0x74
(gdb) continue
Continuing.
Password : test
Bon mot de passe!

Par ailleur, les adresses présente sur le côté droit sont lisible avec la commande suivante :

(gdb) x/1s 0x555555554903
0x555555554903: "pass"
(gdb) x/1s 0x555555554908
0x555555554908: "Bon mot de passe!"

Ainsi on peut même retrouver le mot de passe en clair!

gdb -q ./program
break main
run
set dis intel
info registers

Le format d'affichage :

x/o $eip        = affiche en octal
x/o <offset>    = affiche en octal
x/x $eip        = affiche en hexadecimal
x/u $eip        = affiche en décimal
x/t $eip        = affichage en décimal
x/3i $eip       = affiche les 3 instructions suivante

Par défaut, on peut visualiser une seule unité (un mot / 4 octets) mais on peut voir plusieurs unité l'adresse cible :

x/12x $eip

strings programme

[...]
Password :
pass
Bon mot de passe!
Essait encore!
;*3$"
[...]

On peut retrouver le mot clé “pass” qui est visible en clair!

objdump -D programme |grep -A30 "main>:"

Plus une lecture plus simple, on peut utiliser la syntaxe de intel : objdump -M intel -D programme

00000000000007e0 <main>:
 7e0:   55                      push   %rbp
 7e1:   48 89 e5                mov    %rsp,%rbp
 7e4:   48 83 ec 30             sub    $0x30,%rsp
 7e8:   64 48 8b 04 25 28 00    mov    %fs:0x28,%rax
 7ef:   00 00
 7f1:   48 89 45 f8             mov    %rax,-0x8(%rbp)
 7f5:   31 c0                   xor    %eax,%eax
 7f7:   48 8d 3d f6 00 00 00    lea    0xf6(%rip),%rdi        # 8f4 <_IO_stdin_used+0x4>
 7fe:   b8 00 00 00 00          mov    $0x0,%eax
 803:   e8 88 fe ff ff          callq  690 <.plt.got+0x10>
 808:   48 8d 45 d0             lea    -0x30(%rbp),%rax
 80c:   48 89 c6                mov    %rax,%rsi
 80f:   48 8d 3d ea 00 00 00    lea    0xea(%rip),%rdi        # 900 <_IO_stdin_used+0x10>
 816:   b8 00 00 00 00          mov    $0x0,%eax
 81b:   e8 80 fe ff ff          callq  6a0 <.plt.got+0x20>
 820:   48 8d 45 d0             lea    -0x30(%rbp),%rax
 824:   48 8d 35 d8 00 00 00    lea    0xd8(%rip),%rsi        # 903 <_IO_stdin_used+0x13>
 82b:   48 89 c7                mov    %rax,%rdi
 82e:   e8 65 fe ff ff          callq  698 <.plt.got+0x18>
 833:   85 c0                   test   %eax,%eax
 835:   75 0e                   jne    845 <main+0x65>
 837:   48 8d 3d ca 00 00 00    lea    0xca(%rip),%rdi        # 908 <_IO_stdin_used+0x18>
 83e:   e8 3d fe ff ff          callq  680 <.plt.got>
 843:   eb 0c                   jmp    851 <main+0x71>
 845:   48 8d 3d ce 00 00 00    lea    0xce(%rip),%rdi        # 91a <_IO_stdin_used+0x2a>
 84c:   e8 2f fe ff ff          callq  680 <.plt.got>
 851:   b8 00 00 00 00          mov    $0x0,%eax
 856:   48 8b 55 f8             mov    -0x8(%rbp),%rdx
 85a:   64 48 33 14 25 28 00    xor    %fs:0x28,%rdx
 861:   00 00
 863:   74 05                   je     86a <main+0x8a>
 865:   e8 1e fe ff ff          callq  688 <.plt.got+0x8>
 86a:   c9                      leaveq
 86b:   c3                      retq
 86c:   0f 1f 40 00             nopl   0x0(%rax)

On observe ici une instruction “jne” (à l'emplacement 75 0e) qui doit être liée à la condition pour comparer la saisie attendu par le bon mot de passe. Nous pouvons dans ce cas le remplacer avec une instruction “je” qui aura pour but d'accepter n'importe quelle saisie. Éditons ce code binaire :

hexedit --color programme

On remplace 75 0e par 74 0e puis on sauvegarde cette modification à l'aide de cette suite de touches :

<ctrl>+<w>
<crtl>+<x>

Une fois que l'on relance le programm, on obtient la bonne réponse :

./programme
Password : test
Bon mot de passe!

Dans lequel il faut changer jne par ne (trouver la fonction strcmp)

r2 -w programme
aa
fs symbols
f

0x000007e0 256 main
0x000006b0 43 entry0
0x00200dc8 0 obj.__JCR_LIST__
0x000006e0 50 sym.deregister_tm_clones
0x00000720 66 sym.register_tm_clones
0x00000770 50 sym.__do_global_dtors_aux
0x00201010 1 obj.completed.7561
0x00200dc0 0 obj.__do_global_dtors_aux_fini_array_entry
0x000007b0 48 sym.frame_dummy
0x00200db8 0 obj.__frame_dummy_init_array_entry
0x00000a70 0 obj.__FRAME_END__
0x00200dc8 0 obj.__JCR_END__
0x00200dc0 0 loc.__init_array_end
0x00200dd0 0 obj._DYNAMIC
0x00200db8 0 loc.__init_array_start
0x0000092c 0 loc.__GNU_EH_FRAME_HDR
0x00200f90 0 obj._GLOBAL_OFFSET_TABLE_
0x000008e0 2 sym.__libc_csu_fini
0x00201000 0 loc.data_start
0x00201010 0 loc._edata
0x000008e4 9 sym._fini
0x00201000 0 loc.__data_start
0x00201008 0 obj.__dso_handle
0x000008f0 4 obj._IO_stdin_used
0x00000870 101 sym.__libc_csu_init
0x00201018 0 loc._end
0x000006b0 43 sym._start
0x00201010 0 loc.__bss_start
0x000007e0 140 sym.main
0x00201010 0 obj.__TMC_END__
0x00000658 23 sym._init

On sélectionne ensuite la fonction principale qui nous intéresse :

pdf@sym.main
[0x000006b0]> pdf@sym.main 
            ;-- main:
/ (fcn) sym.main 140
|   sym.main ();
|           ; var int local_30h @ rbp-0x30
|           ; var int local_8h @ rbp-0x8
|           ; DATA XREF from 0x000006cd (entry0)
|           0x000007e0      55             push rbp
|           0x000007e1      4889e5         mov rbp, rsp
|           0x000007e4      4883ec30       sub rsp, 0x30               ; '0'
|           0x000007e8      64488b042528.  mov rax, qword fs:[0x28]    ; [0x28:8]=0x1a60 ; '('
|           0x000007f1      488945f8       mov qword [rbp - local_8h], rax
|           0x000007f5      31c0           xor eax, eax
|           0x000007f7      488d3df60000.  lea rdi, qword str.Password_: ; 0x8f4 ; str.Password_: ; "Password : " @ 0x8f4
|           0x000007fe      b800000000     mov eax, 0
|           0x00000803      e888feffff     call section_end..symtab
|           0x00000808      488d45d0       lea rax, qword [rbp - local_30h]
|           0x0000080c      4889c6         mov rsi, rax
|           0x0000080f      488d3dea0000.  lea rdi, qword 0x00000900   ; 0x900 ; "%s"
|           0x00000816      b800000000     mov eax, 0
|           0x0000081b      e880feffff     call 0x6a0
|           0x00000820      488d45d0       lea rax, qword [rbp - local_30h]
|           0x00000824      488d35d80000.  lea rsi, qword str.pass     ; 0x903 ; str.pass ; "pass" @ 0x903
|           0x0000082b      4889c7         mov rdi, rax
|           0x0000082e      e865feffff     call 0x698
|           0x00000833      85c0           test eax, eax
|       ,=< 0x00000835      750e           jne 0x845
|       |   0x00000837      488d3dca0000.  lea rdi, qword str.Bon_mot_de_passe_ ; 0x908 ; str.Bon_mot_de_passe_ ; "Bon mot de passe!" @ 0x908
|       |   0x0000083e      e83dfeffff     call 0x680
|      ,==< 0x00000843      eb0c           jmp 0x851
|      |`-> 0x00000845      488d3dce0000.  lea rdi, qword str.Essait_encore_ ; 0x91a ; str.Essait_encore_ ; "Essait encore!" @ 0x91a
|      |    0x0000084c      e82ffeffff     call 0x680
|      |    ; JMP XREF from 0x00000843 (sym.main)
|      `--> 0x00000851      b800000000     mov eax, 0
|           0x00000856      488b55f8       mov rdx, qword [rbp - local_8h]
|           0x0000085a      644833142528.  xor rdx, qword fs:[0x28]
|       ,=< 0x00000863      7405           je 0x86a
|       |   0x00000865      e81efeffff     call 0x688
|       `-> 0x0000086a      c9             leave
\           0x0000086b      c3             ret

En un coup d'observation, on peut remarquer que le mot de passe est affiché en clair à l'adresse 0x00000824 :

0x00000824      488d35d80000.  lea rsi, qword str.pass     ; 0x903 ; str.pass ; "pass" @ 0x903

wx 743B @ offset (74=je / 75=jne)
wa je @offset
pd 256
pxw @offset
pcp @offset (print dans le format de python)
s= (liste les sections)
s (voir sa position)
px @offset (printe hexa)
pz @offset (print data)
s 0xoffset (se déplacer)
àà+ (entrer en mode écriture)

f ~Wrong
axf str.Wrong_passwd
pdf@offset

Il est également possible d'analyser et d'éditer directement le programme compilé avec Vim!

vim programme

On se met en mode édition hexadécimal :

:%!xxd

On modifie “75 0e” par “74 0e” puis on se remet en format ASCII :

:%!xxd -r

Et on sauvegarde :

:w

On obtient ainsi la bonne réponse :

./programme
Password : test
Bon mot de passe!

hexdump -C programme |less
readelf -a programme |less
ht programme

Ou même en mode graphique avec edb debugger : https://github.com/eteran/edb-debugger