Se connecter

Blabla 18-25 ans
Sujet : Challenge DGSE
1
29
31
cduret
Niveau 2
03 juin 2019 à 00:43:55

J'arrive maintenant a executer n'importe quel code mais quand j'essaie d'avoir un shell ça ne fonctionne pas.

Si je fais juste un syscall execve avec /bin/sh il me donne ça :

$ cat exploit | strace ./prog.bin
...
execve("/bin/sh", [], [/* 0 vars */]) = 0
brk(NULL) = 0x55c2562ea000
access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)
access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory)
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=23880, ...}) = 0
mmap(NULL, 23880, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f20e12cd000
close(3) = 0
access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)
open("/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\0\4\2\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=1689360, ...}) = 0
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f20e12cb000
mmap(NULL, 3795296, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f20e0d11000
mprotect(0x7f20e0ea6000, 2097152, PROT_NONE) = 0
mmap(0x7f20e10a6000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x195000) = 0x7f20e10a6000
mmap(0x7f20e10ac000, 14688, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7f20e10ac000
close(3) = 0
arch_prctl(ARCH_SET_FS, 0x7f20e12cc480) = 0
mprotect(0x7f20e10a6000, 16384, PROT_READ) = 0
mprotect(0x55c2547e5000, 8192, PROT_READ) = 0
mprotect(0x7f20e12d3000, 4096, PROT_READ) = 0
munmap(0x7f20e12cd000, 23880) = 0
getpid() = 24
rt_sigaction(SIGCHLD, {sa_handler=0x55c2545dbef0, sa_mask=~[RTMIN RT_1], sa_flags=SA_RESTORER, sa_restorer=0x7f20e0d44060}, NULL, 8) = 0
geteuid() = 1000
brk(NULL) = 0x55c2562ea000
brk(0x55c25630b000) = 0x55c25630b000
getppid() = 22
getcwd("/home/defi2", 4096) = 12
ioctl(0, TCGETS, 0x7ffc73e8fa20) = -1 ENOTTY (Inappropriate ioctl for device)
rt_sigaction(SIGINT, NULL, {sa_handler=SIG_DFL, sa_mask=[], sa_flags=0}, 8) = 0
rt_sigaction(SIGINT, {sa_handler=SIG_DFL, sa_mask=~[RTMIN RT_1], sa_flags=SA_RESTORER, sa_restorer=0x7f20e0d44060}, NULL, 8) = 0
rt_sigaction(SIGQUIT, NULL, {sa_handler=SIG_DFL, sa_mask=[], sa_flags=0}, 8) = 0
rt_sigaction(SIGQUIT, {sa_handler=SIG_DFL, sa_mask=~[RTMIN RT_1], sa_flags=SA_RESTORER, sa_restorer=0x7f20e0d44060}, NULL, 8) = 0
rt_sigaction(SIGTERM, NULL, {sa_handler=SIG_DFL, sa_mask=[], sa_flags=0}, 8) = 0
rt_sigaction(SIGTERM, {sa_handler=SIG_DFL, sa_mask=~[RTMIN RT_1], sa_flags=SA_RESTORER, sa_restorer=0x7f20e0d44060}, NULL, 8) = 0
read(0, "", 8192) = 0
exit_group(0) = ?
+++ exited with 0 +++

j'ai essayé de mettre un setuid(0) devant mais il me retourne -1 permission denied
:(

cannic
Niveau 2
03 juin 2019 à 05:38:15

Si je fais juste un syscall execve avec /bin/sh il me donne ça :

$ cat exploit | strace ./prog.bin
...
execve("/bin/sh", [], [/* 0 vars */]) = 0

(...)

read(0, "", 8192) = 0
exit_group(0) = ?
+++ exited with 0 +++

j'ai essayé de mettre un setuid(0) devant mais il me retourne -1 permission denied
:(

setuid(0) ne va pas fonctionner. C'est un appel pour obtenir les droits de root mais le propriétaire du fichier (et donc sous lequel tourne prog2.bin) n'est pas root. C'est juste un utilisateur normal qui peut lire le fichier drapeau.txt.

Le problème ici c'est que tu executes bien un shell mais il essaye de lire stdin (fd 0) pour lire des commandes et comme ton fichier exploit ne s'arrête la read() retourne 0 (pour end of file) et le shell s'arrête.

Il y a deux solutions possibles:

1) tu ajoutes des espaces à exploit qui seront lus pendant le read() initial dans prog2.bin (4K ou 8K) puis tu ajoutes la commande que tu veux executer

2) Tu changes ton shellcode pour faire par exemple un execve "/bin/cat drapeau.txt" au lieu d'executer un shell.

cduret
Niveau 2
03 juin 2019 à 12:02:03

execve("/bin/cat", ["/bin/cat", "drapeau.txt"], NULL) = 0

et ça marche nickel :rire:

@cannic merci pour ton aide precieuse

Kappawaii
Niveau 3
04 juin 2019 à 16:55:16

Vous avez utilisé quels gadgets pour la ROPchain ? je trouve pas de combinaisons intéressantes :non:

cduret
Niveau 2
04 juin 2019 à 17:10:18

Si tu trouve le bon overflow, c'est pas un problème de trouver les bon gadgets, ça sera evident

cannic
Niveau 2
04 juin 2019 à 17:45:39

Le binaire est petit, il y a donc peu de gadgets. Mais garde bien à l'esprit que la pile du programme est exécutable, tu n'as pas donc besoin de tout faire en ROP. Un gadget qui te permet de déplacer l'exécution sur la pile serait suffisant.

cduret
Niveau 2
04 juin 2019 à 18:36:30

par contre pour le defi3, j'arrive meme pas a trouver l'overflow :ouch2: , tous inputs des strcpy viennent d'un fgets qui lui même possède un check sur la taille du buffer.

La seule possibilité serait d'arriver à mettre une taille d'id > 1280 octets pour pouvoir faire un overflow.
Mais cette valeur est remise par defaut si elle depasse 100 :(

cduret
Niveau 2
04 juin 2019 à 21:07:53

ok vu mon manque de "hacker" culture, il faut peut-être s'orienter vers :

https://www.owasp.org/indndex.php/Doubly_freeing_memory

:-d

TheNewOneXXX
Niveau 10
04 juin 2019 à 21:09:35

Vous avez toujours pas trouvé? Faut s’activer :(

terudc
Niveau 1
04 juin 2019 à 22:58:15

Bonjour à tous,

Idem je suis aussi bloqué sur le défi3. Je pense que c'est un Heap Overflow avec le malloc. Mais le seul Segmentation fault que je trouve, je n'arrive pas à l'exploiter.

ps : suite dans l'autre post

defi3@AttrapeLeDrapeau:~$ ltrace ./prog.bin 100 < a.txt
malloc(240)                                                                                                                   = 0xda6010
atoi(0x7ffc76dca980, 0xda6100, 0xda6010, 0x7f49e38c6b00)                                                                      = 100
puts("********************************"...***************************************************
)                                                                                   = 52
puts("***    Bienvenue dans la gestion"...***    Bienvenue dans la gestion d'éléments     ***
)                                                                                   = 54
puts("***                             "...***                                             ***
)                                                                                   = 52
printf("***   NB : Taille de l'ID : %2d "..., 100***   NB : Taille de l'ID : 100 octets           ***
)                                                                            = 53
puts("***        Vous pouvez mettre la"...***        Vous pouvez mettre la taille         ***
)                                                                                   = 52
puts("***        en param\303\250tre pour la"...***        en paramètre pour la changer         ***
)                                                                             = 53
puts("********************************"...***************************************************
)                                                                                   = 52
puts("Que voulez-vous faire ?\n  -> 1) "...Que voulez-vous faire ?
  -> 1) nouvel élément
  -> 2) affichage
  -> 3) détruire un élément
  -> 4) changer de nom
  -> 5) changer d'id
  -> 6) sortie
)                                                                                  = 157
printf("choix $ ")                                                                                                            = 8
fgets("1\n", 256, 0x7f49e38c68c0)                                                                                             = 0x7ffc76dc8b90
strlen("1\n")                                                                                                                 = 2
atoll(0x7ffc76dc8b90, 0x7f49e38c8770, 0xc0fc, 2960)                                                                           = 1
malloc(16)                                                                                                                    = 0xda7530
printf("\303\251l\303\251ment %d\t\t\tentrez nom $ ", 0)                                                                      = 27
fgets("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"..., 1280, 0x7f49e38c68c0)                                                            = 0x7ffc76dc8770
strlen("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"...)                                                                                 = 1279
strlen("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"...)                                                                                 = 1278
malloc(1279)                                                                                                                  = 0xda7550
strcpy(0xda7550, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"...)                                                                       = 0xda7550
printf("\303\251l\303\251ment %d (%2d octets max)\ten"..., 0, 100)                                                            = 41
fgets("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"..., 102, 0x7f49e38c68c0)                                                             = 0x7ffc76dc8770
strlen("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"...)                                                                                 = 93
malloc(101)                                                                                                                   = 0xda7a60
strcpy(0xda7a60, "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"...)                                                                       = 0xda7a60
puts("Que voulez-vous faire ?\n  -> 1) "...choix $ élément 0      entrez nom $ élément 0 (100 octets max) entrez id $ Que voulez-vous faire ?
  -> 1) nouvel élément
  -> 2) affichage
  -> 3) détruire un élément
  -> 4) changer de nom
  -> 5) changer d'id
  -> 6) sortie
)                                                                                  = 157
printf("choix $ ")                                                                                                            = 8
fgets("1\n", 256, 0x7f49e38c68c0)                                                                                             = 0x7ffc76dc8b90
strlen("1\n")                                                                                                                 = 2
atoll(0x7ffc76dc8b90, 0x7f49e38c8770, 0xc0fc, 2960)                                                                           = 1
malloc(16)                                                                                                                    = 0xda7ad0
printf("\303\251l\303\251ment %d\t\t\tentrez nom $ ", 1)                                                                      = 27
fgets("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"..., 1280, 0x7f49e38c68c0)                                                            = 0x7ffc76dc8770
strlen("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"...)                                                                                 = 1279
strlen("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"...)                                                                                 = 1278
malloc(1279)                                                                                                                  = 0xda7af0
strcpy(0xda7af0, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"...)                                                                       = 0xda7af0
printf("\303\251l\303\251ment %d (%2d octets max)\ten"..., 1, 100)                                                            = 41
fgets("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"..., 102, 0x7f49e38c68c0)                                                             = 0x7ffc76dc8770
strlen("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"...)                                                                                 = 93
malloc(101)                                                                                                                   = 0xda8000
strcpy(0xda8000, "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"...)                                                                       = 0xda8000
puts("Que voulez-vous faire ?\n  -> 1) "...choix $ élément 1      entrez nom $ élément 1 (100 octets max) entrez id $ Que voulez-vous faire ?
  -> 1) nouvel élément
  -> 2) affichage
  -> 3) détruire un élément
  -> 4) changer de nom
  -> 5) changer d'id
  -> 6) sortie
)                                                                                  = 157
printf("choix $ ")                                                                                                            = 8
fgets("3\n", 256, 0x7f49e38c68c0)                                                                                             = 0x7ffc76dc8b90
strlen("3\n")                                                                                                                 = 2
atoll(0x7ffc76dc8b90, 0x7f49e38c8770, 0xc0fc, 2960)                                                                           = 3
printf("lequel $ ")                                                                                                           = 9
fgets("1\n", 256, 0x7f49e38c68c0)                                                                                             = 0x7ffc76dc8bb0
strlen("1\n")                                                                                                                 = 2
atoll(0x7ffc76dc8bb0, 0x7f49e38c8770, 0xc0fc, 2992)                                                                           = 1
printf("quoi (id : 1   nom : 2) $ ")                                                                                          = 26
fgets("2\n", 256, 0x7f49e38c68c0)                                                                                             = 0x7ffc76dc8bb0
strlen("2\n")                                                                                                                 = 2
atoll(0x7ffc76dc8bb0, 0x7f49e38c8770, 0xc0fc, 2992)                                                                           = 2
free(0xda7af0)                                                                                                                = <void>
puts(""choix $ lequel $ quoi (id : 1   nom : 2) $
)                                                                                                                      = 1
puts("Que voulez-vous faire ?\n  -> 1) "...Que voulez-vous faire ?
  -> 1) nouvel élément
  -> 2) affichage
  -> 3) détruire un élément
  -> 4) changer de nom
  -> 5) changer d'id
  -> 6) sortie
)                                                                                  = 157
printf("choix $ ")                                                                                                            = 8
fgets("1\n", 256, 0x7f49e38c68c0)                                                                                             = 0x7ffc76dc8b90
strlen("1\n")                                                                                                                 = 2
atoll(0x7ffc76dc8b90, 0x7f49e38c8770, 0xc0fc, 2960)                                                                           = 1
malloc(16)                                                                                                                    = 0xda7af0
printf("\303\251l\303\251ment %d\t\t\tentrez nom $ ", 2)                                                                      = 27
fgets("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"..., 1280, 0x7f49e38c68c0)                                                            = 0x7ffc76dc8770
strlen("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"...)                                                                                 = 1279
strlen("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"...)                                                                                 = 1278
malloc(1279)                                                                                                                  = 0xda8070
strcpy(0xda8070, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"...)                                                                       = 0xda8070
printf("\303\251l\303\251ment %d (%2d octets max)\ten"..., 2, 100)                                                            = 41
fgets("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"..., 102, 0x7f49e38c68c0)                                                             = 0x7ffc76dc8770
strlen("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"...)                                                                                 = 93
malloc(101)                                                                                                                   = 0xda7b10
strcpy(0xda7b10, "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"...)                                                                       = 0xda7b10
puts("Que voulez-vous faire ?\n  -> 1) "...choix $ élément 2      entrez nom $ élément 2 (100 octets max) entrez id $ Que voulez-vous faire ?
  -> 1) nouvel élément
  -> 2) affichage
  -> 3) détruire un élément
  -> 4) changer de nom
  -> 5) changer d'id
  -> 6) sortie
)                                                                                  = 157
printf("choix $ ")                                                                                                            = 8
fgets("3\n", 256, 0x7f49e38c68c0)                                                                                             = 0x7ffc76dc8b90
strlen("3\n")                                                                                                                 = 2
atoll(0x7ffc76dc8b90, 0x7f49e38c8770, 0xc0fc, 2960)                                                                           = 3
printf("lequel $ ")                                                                                                           = 9
fgets("1\n", 256, 0x7f49e38c68c0)                                                                                             = 0x7ffc76dc8bb0
strlen("1\n")                                                                                                                 = 2
atoll(0x7ffc76dc8bb0, 0x7f49e38c8770, 0xc0fc, 2992)                                                                           = 1
printf("quoi (id : 1   nom : 2) $ ")                                                                                          = 26
fgets("2\n", 256, 0x7f49e38c68c0)                                                                                             = 0x7ffc76dc8bb0
strlen("2\n")                                                                                                                 = 2
atoll(0x7ffc76dc8bb0, 0x7f49e38c8770, 0xc0fc, 2992)                                                                           = 2
free(0xda7af0)                                                                                                                = <void>
puts(""choix $ lequel $ quoi (id : 1   nom : 2) $
)                                                                                                                      = 1
puts("Que voulez-vous faire ?\n  -> 1) "...Que voulez-vous faire ?
  -> 1) nouvel élément
  -> 2) affichage
  -> 3) détruire un élément
  -> 4) changer de nom
  -> 5) changer d'id
  -> 6) sortie
)                                                                                  = 157
printf("choix $ ")                                                                                                            = 8
terudc
Niveau 1
04 juin 2019 à 22:58:48

suite

fgets("2\n", 256, 0x7f49e38c68c0)                                                                                             = 0x7ffc76dc8b90
strlen("2\n")                                                                                                                 = 2
atoll(0x7ffc76dc8b90, 0x7f49e38c8770, 0xc0fc, 2960)                                                                           = 2
puts("~~~~~~~~~~~~~"choix $ ~~~~~~~~~~~~~
)                                                                                                         = 14
puts("~~ \303\251l\303\251ment ~~"~~ élément ~~
)                                                                                           = 16
puts("~~~~~~~~~~~~~"~~~~~~~~~~~~~
)                                                                                                         = 14
printf("  \303\251l\303\251ment[%d]\t-> nom : %s\n", 0, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"...  élément[0] -> nom : AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
)                                = 1303
printf("  \303\251l\303\251ment[%d]\t-> id : %s\n\n", 0, "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"...  élément[0]  -> id : BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

)                               = 117
printf("  \303\251l\303\251ment[%d]\t-> nom : %s\n", 1, ""  élément[1]  -> nom :
)                                                                   = 25
printf("  \303\251l\303\251ment[%d]\t-> id : %s\n\n", 1, "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"...  élément[1]  -> id : BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

)                               = 117
printf("  \303\251l\303\251ment[%d]\t-> nom : %s\n", 2, nil  élément[2] -> nom : (null)
)                                                                  = 31
printf("  \303\251l\303\251ment[%d]\t-> id : %s\n\n", 2, "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"...  élément[2]  -> id : BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

)                               = 117
puts("Que voulez-vous faire ?\n  -> 1) "...Que voulez-vous faire ?
  -> 1) nouvel élément
  -> 2) affichage
  -> 3) détruire un élément
  -> 4) changer de nom
  -> 5) changer d'id
  -> 6) sortie
)                                                                                  = 157
printf("choix $ ")                                                                                                            = 8
fgets("4\n", 256, 0x7f49e38c68c0)                                                                                             = 0x7ffc76dc8b90
strlen("4\n")                                                                                                                 = 2
atoll(0x7ffc76dc8b90, 0x7f49e38c8770, 0xc0fc, 2960)                                                                           = 4
printf("lequel $ ")                                                                                                           = 9
fgets("2\n", 256, 0x7f49e38c68c0)                                                                                             = 0x7ffc76dc8bb0
strlen("2\n")                                                                                                                 = 2
atoll(0x7ffc76dc8bb0, 0x7f49e38c8770, 0xc0fc, 2992)                                                                           = 2
printf("\303\251l\303\251ment %d\tentrez nom $ ", 2)                                                                          = 25
fgets("ZZZZ\n", 9, 0x7f49e38c68c0)                                                                                            = 0x7ffc76dc8ce0
strlen("ZZZZ\n")                                                                                                              = 5
strcpy(0, "ZZZZ" <no return ...>
--- SIGSEGV (Segmentation fault) ---
+++ killed by SIGSEGV +++
cannic
Niveau 2
04 juin 2019 à 23:23:57

Idem je suis aussi bloqué sur le défi3. Je pense que c'est un Heap Overflow avec le malloc. Mais le seul Segmentation fault que je trouve, je n'arrive pas à l'exploiter.

Il y a en effet plusieurs débordements possibles sur le tas mais il y a aussi d'autres types de vulnérabilités exploitables.

terudc
Niveau 1
05 juin 2019 à 22:40:41

:merci: @cannic pour cette réponse rapide.

Du coup j'ai regardé d'autres techniques comme :

LD_PRELOAD :
defi3@AttrapeLeDrapeau:~$ LD_PRELOAD="/home/defi3/e" ldd ./prog.bin linux-vdso.so.1 (0x00007ffd64f3e000) /home/defi3/e (0x00007f40e22f6000) libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f40e1f57000) /lib64/ld-linux-x86-64.so.2 (0x00007f40e24f8000) defi3@AttrapeLeDrapeau:~$ ldd ./prog.bin linux-vdso.so.1 (0x00007fffc4df3000) libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f44f856c000) /lib64/ld-linux-x86-64.so.2 (0x00007f44f890b000)

Mon exploit n'a aucun effet :

LD_PRELOAD="/home/defi3/e" ./prog.bin

Il fonctionne uniquement avec ltrace mais je perd le SUID :

LD_PRELOAD="/home/defi3/e" ltrace ./prog.bin

C'est un comportement normal ou peut être une protection qui m'échappe :question:

terudc
Niveau 1
05 juin 2019 à 23:02:46

J'ai trouvé ma réponse, conclusion je reprend les failles depuis le début sauf si je modifie mon euid après le lancement bin :doute:

Gain root privileges. Not really, don’t even bother, you won’t bypass any security this way. (A quick explanation for pros: no libraries will be preloaded this way if ruid != euid)

K8LM
Niveau 6
05 juin 2019 à 23:06:45

Comment on s'inscrit ? :hap:

TheNewOneXXX
Niveau 10
05 juin 2019 à 23:07:40

Tic tac tic tac tic tac :)

terudc
Niveau 1
05 juin 2019 à 23:43:49

Le 05 juin 2019 à 23:06:45 K8LM a écrit :
Comment on s'inscrit ? :hap:

Pas d'inscription juste un lien pour commencer https://www.challengecybersec.fr ;)

cduret
Niveau 2
06 juin 2019 à 10:59:22

Je vois bien qu'avec un double free on peut avoir la meme addresse avec un malloc mais je ne vois pas comment introduire un depassement dans cette mémoire sachant que le fgets du menu 4 (changer de nom) est limité à 9 ? et que si on utilise le champs id pour faire le double free, le malloc est toujours fixe...

Si je fais avec le menu :
1
A
B
1
C
D
3
0
2
3
1
2
3
0
2
1
E
F
2

Le pointeur sur le nom de l'element 1 et l'element 2 est le même

~~~~~~~~~~~~~
~~ élément ~~
~~~~~~~~~~~~~
élément[0] -> nom : �
élément[0] -> id : B

élément[1] -> nom : E
élément[1] -> id : D

élément[2] -> nom : E
élément[2] -> id : F

:doute:

cannic
Niveau 2
06 juin 2019 à 16:08:51

:>Je vois bien qu'avec un double free on peut avoir la meme addresse avec un malloc mais je ne vois pas comment introduire un depassement dans cette mémoire

Il y bien un moyen de faire un dépassement en profitant du fait que la valeur de retour de fgets() n'est pas testée. Mais ce n'est pas forcément facilement exploitable.

Tu restes bloqué sur l'idée de faire plusieurs free() de la même adresse, mais le code t'ouvre d'autres possibilités vu que par exemple le bloc peut être utilisé pour une allocation ultérieure.

ESIEE_P
Niveau 1
06 juin 2019 à 22:48:18

Je vois que certain sont resté bloqué à reconstituer le prime1
quelques infos sur RSA:
N = p * q

Prime1 = p
Prime2 = q

Public.key est constitué à partir de N et d'un Public Exponent "e"
Private.key est constitué à partir de N et d'un Private Exponent "d"

Pour retrouver N et e à partir de la clé public :
$ openssl -pubin -in public.key -text -noout

Mon script python pour retrouver prime1, prime2 et d :

#! /usr/bin/python
# -*- coding: utf-8 -*-`

import sys
import itertools
from itertools import product

#fonction modular inverse pour calculer d

def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)

def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m

prime1 = '00 fb 40 dc 44 ba 03 d1 53 42 f7 59 08 e0 f9 30 05 96 64 4a de 94 68 5e 08 e2 8c 9a b1 64 0c 2f 62 c2 9a b9 a2 39 82 4b 9e be eb 76 ae 6d 87 21 a3 5e 9e d9 8d 7e 57 38 3e 59 09 34 a5 78 cd f7 2e 89 5d 5c 37 52 ea fd f6 31 cc ba d2 d9 60 e4 45 1d 67 76 d2 1f 12 9c 9d c9 b1 90 45 51 ed d2 fb dd b6 74 b4 99 fb b1 0a d9 b7 c2 be 8b 57 07 22 0a 8e 3a 36 ff 6d c1 1d 63 93 af cb 4e c0 47 9f 65 bf df e3 f0 5f 1e 98 61 45 74 ec 36 a7 a5 b1 f1 8d 3d 97 6b 5a 82 49 09 00 08 0d 9d c2 74 57 4e 30 a1 39 68 2f 22 34 71 13 aa 3b f2 20 4f 8e 10 eb d4 d0 9b cd 8c c2 53 5f 9d 71 13 0c 0f 21 b6 6e 13 39 40 d3 a6 b1 eb 74 ad dd 0a 29 14 81 b1 90 ad e0 53 f0 89 c8 00 fe dc ad 56 59 fc 28 1d c0 cf 5e 08 c0 54 33 24 a3 52 bb f3 25 10 43 c3 73 b8 40 4f fc 6b 6b 77 bd 5f 22 24 eb fb 15'

combination = {'fb':['7f','fb'],'12':['f4','12'],'54':['16','54'],'57':['a4','57'],'cd':['b5','cd']}

lst = [[word] + list(combination[word]) if word in combination else [word] for word in prime1.split()]

resultat = [''.join(line) for line in product(*lst)]
resultat2 = list(set(resultat)) #supprime les doublons

N = 0x00cd5f8a24c7605008897a3c922c0e812e769de0a46442c350cb78c7868539f3d38aac80b3e6a506605910e8599806b4d1d148f2f6b81da04796a8a5aee18f29e83e16775a2a0a00870541f6574ed1438636ae0a0c116e07104f48f72094863a3869e1c8fc220627278962fb22873e3156f18e55dec94e970064ec7f4e0e88454012e2fd5dfe5f8d19bf170f9ccb3f46e0fd1019bcb02d9083a0703c617f996379e6478354a73ae6e6acbce1f4333ecfaf24366a3e977d3cd3cbfe8d8a387bd876bfdab8488f6f47bf1fbe33010fd2d7e22b4db2e567783ce0b606db86b93759714c4f6396a7fb9f74c4021043b0f3d46d2633ebd43a877863df7d680f506587c119dd64100ca831ce2af33d951b524c5f06b49f5bf2cb381e74181930d06a80505c06abd5bf4870f0c9fb581bd80dba889660639f936edea8fe5d0c9eae58062ed693252583c71cc782ba613e01438e69b43f9e64eca84f9ea04e811ad7b39efd7876d1b6b501c4f48acce6f24239f6c04028788135cd88c3d15be0f2ebb7de9e9c19a7a93037005ee0a9a640bada332ec0d05ee9f08a832354a0487a927d5e88066e2569e6c5d4688e422bfa0b27c6171c6d7bf029bfd9165752af19aa71b33a1ea70b6c371fb21e47f527d80b7d04f582ad9f9935af723682dc01ca9880621870decb7ad15648cdf4ef153016f3e6d87933b8ec54cfa1fdf87c467020a3e753
print("Modulo N :", N)

e = 65537
print("Public Exponent e : ", e)

i = 0
nb_possibilite = 0

for p in resultat2:
nb_possibilite += 1
if (N % long(p.strip('\n'), 16) == 0):
prime1 = p
print("prime1 : ", prime1)
i +=1
p = long(p, 16)
q = N / p
print("prime2 : ", q)
phi = (p-1)*(q-1)
d = modinv(e, phi)
print("Private Exponent d : ", d)

print("Nombre de possibilite : ", nb_possibilite)
print("Nombre de prime1 : ", i)

Pour retrouver la clé privée (au format PEM) avec N et d :
github.com/ius/rsatool
python rsatool.py -f PEM -o private.pem -n {N en decimal} -d {d en decimal}

Enfin, pour décrypter motDePasseGPG.txt.enc :
$ openssl rsault -decrypt -in motDePasseGPG.txt.enc -inkey private.pem -out motDePasseGPG.txt

1
29
31
Sujet : Challenge DGSE
   Retour haut de page
Consulter la version web de cette page