Archivo

Posts Tagged ‘hacking tor’

2015, año en el que deberías comenzar a pensar en I2P.

febrero 3, 2015 2 comentarios

TOR es la red anónima más extendida, conocida (y atacada) del mundo y sin duda gran parte de su éxito se debe a que es una red que provee unos buenos niveles de anonimato y privacidad para cualquier usuario en Internet. Sin embargo, para nadie es un secreto que se trata de una red que se ha convertido en el principal objetivo de varios gobiernos y agencias en todo el mundo. Son muchos los que constantemente intentan realizar ataques contra la infraestructura de TOR, la cual se basa principalmente en la gente que “desinteresadamente” decide exponer su máquina como un repetidor y así, hacer que la red sea más grande y difícil de atacar. 2014 ha sido un año complicado para TOR, ya que se han descubierto varios ataques exitosos que han sido admitidos por el equipo del proyecto de los cuales aun no se conoce su impacto real, por este motivo, cuando hablamos de TOR, desafortunadamente ya no podemos hablar de un anonimato fuerte. Hay varias cosas que personalmente me gustan del proyecto, es muy interesante y cuenta con una comunidad de desarrolladores/contribuidores enorme, sin embargo hay otras que las considero no solamente mejorables, sino claro un fallo de diseño que ahora le esta pasando factura al proyecto. No pretendo criticar la arquitectura y diseño de TOR, aun así creo que hoy en día, con la cantidad de “rivales” y entidades con intenciones de romper el anonimato de los usuarios que usan esta red, ya es una cuestión de tiempo que su arquitectura y diseño se vuelvan indefendibles. Mis razones para afirmar esto son las siguientes:

- Red centralizada: Las autoridades de directorio son servidores que se encargan de mantener viva la red, de gestionar y verificar el estado de cada repetidor participante, emitir los ficheros de consenso que son utilizados por los clientes para componer sus circuitos, mantener un registro de “Introduction Points”, “Rendezvous Points” y las tablas de servicios ocultos registrados en la red, entre muchas otras labores de administración que son completamente transparentes para los usuarios. Esto es mucho, pero que mucho poder para ser manejado únicamente 10 ordenadores. Esta claro que un ataque dirigido contra algunos de estos ordenadores (o todos) puede generar un caos en la red y esto es algo que ya ha pasado entre los meses de octubre y diciembre del 2014, en los que se llevaron acabo ataques de DoS distribuidos contra algunas de las autoridades de directorio de TOR. El resultado: Gran parte de la red se mantuvo saturada durante varias horas y era prácticamente imposible acceder a la web profunda de TOR. Ahora bien, no tengo constancia de que existan campañas de APT contra dichos servidores, pero no me extrañaría, es más, hoy en día nadie puede garantizar con un 100% de certeza que todas las autoridades de directorio de TOR están siendo controladas única y exclusivamente por el equipo de TOR.

- Red basada en las buenas intenciones: Cuando un cliente de TOR registra su instancia como un repetidor en la red, las autoridades de directorio se encargan de verificar varios parámetros relacionados con el rendimiento óptimo del repetidor y si se trata de una instancia maliciosa basándose principalmente en un mecanismo de listas negras. Sin embargo sino hay ningún problema, el repetidor es incluido en el consenso que emiten las autoridades de directorio cada hora y ahora, alguien que efectivamente no conoces pasa a ser el repetidor de salida del circuito que te permite conectarte con la web profunda de TOR. Tal como lo han demostrado la inmensa cantidad de ataques que se han llevado a cabo en el 2014, las autoridades de directorio de TOR no pueden saber si un repetidor concreto es malicioso hasta que es detectado y reportado, algo que puede tardar meses. Este es un problema que tiene difícil solución, pero que se convierte en una situación particularmente problemática dado que los circuitos en TOR son bidireccionales.

- Circuitos bidireccionales: Cuando un cliente de TOR se conecta a la red, utiliza un circuito compuesto por 3 repetidores, uno de entrada, uno intermedio y uno de salida. Dicho circuito es bidireccional, lo que quiere decir que funciona tanto para enviar como para recibir paquetes de datos para y desde un destino determinado. Este modelo seria desastroso para una red anónima pequeña, pero ese no es el caso de TOR, ya que la cantidad de voluntarios en todo el mundo es enorme, pero tal como comentaba anteriormente cualquiera puede exponer su ordenador como un repetidor en la red y aunque las autoridades de directorio cuentan con rutinas para la detección de repetidores maliciosos, al final se basan en una relación de confianza y si no hay indicios que demuestren lo contrario, las autoridades de TOR se fían de los clientes que registran sus instancias como repetidores de cualquier tipo. Si hablamos de un adversario con suficientes recursos, puede registrar una gran cantidad de repetidores en la red de TOR y controlar gran parte del trafico de los usuarios y dado que los circuitos en TOR son bidireccionales, realizar ataques basados en los tiempos de las peticiones/repuestas, correlacionales y análisis de trafico para identificar a un usuario, es mucho más sencillo de implementar. Imaginaros por un segundo, ¿Qué pasaría si los circuitos fueran unidireccionales? Pues que este tipo de ataques dejarían de ser viables, dado que teóricamente no habría forma de correlaccionar el trafico de un circuito con otro basándose únicamente en las estadísticas, eso sin contar con que para el adversario seria necesario contar con el doble de recursos para controlar dos circuitos distintos. - ¿Únicamente TCP? La red de TOR únicamente soporta protocolos de red basados en TCP, como por ejemplo HTTP, FTP, SSH, etc. Sin embargo, si se utiliza cualquier otro servicio basado en un protocolo de red distinto, como es el caso de DNS, puede existir una fuga de información que posiblemente revelará la identidad del usuario, ya que es trafico que no pasará por medio de TOR. Dicho en otras palabras, si una de tus aplicaciones ejecuta peticiones DNS para resolver una dirección IP o un nombre de dominio, dichas peticiones producirán una fuga de información, es más, si simplemente haces un “ping” contra otra máquina, también se producirá una fuga de información. TOR solamente soporta TCP, y peticiones DNS (UDP) o un simple “ping” (ICMP) pueden arruinar tu anonimato. Si bien es cierto que existen aplicaciones como “torsocks” que permiten hacer un “torify” de de las aplicaciones para que todo pase por medio de TOR, la realidad es que las fugas de información siguen siendo un problema bastante común.

- Servicios ocultos. ¿Cuándo va a terminar de cargar mi página?!

En TOR no solamente existen servicios ocultos del tipo HTTP, los hay de todo tipo (siempre y cuando se basen en TCP), pero independiente del tipo de servicio que usemos siempre hay una característica que es común a todos: Son LENTOS. Alguna vez te has preguntado ¿por qué demonios los servicios ocultos en TOR son tan lentos? Probablemente alguien te habrá dicho que es porque el trafico se replica entre varios nodos, por esos son lentos. Eso es FALSO, los servicios ocultos son lentos no solamente porque existan repetidores de por medio, son lentos porque cada servicio oculto se encuentra registrado en una base de datos (hash) que comparten las autoridades de directorio para mantener un registro de las direcciones onion de cada servicio con su correspondiente “Introduction Point”. Dado que dicho proceso es centralizado y el número de direcciones onion es gigantesco, es perfectamente normal presenciar una demora cuando se solicita acceso a un servicio onion, eso sin contar que para preservar el anonimato en ambas partes (tanto para el cliente como para el proveedor del servicio) existen dos circuitos independientes que se conectan entre si para la transferencia de datos entre cliente y servidor. Todo esto ya os lo contaba en un articulo anterior Ahora bien, es un problema que no tendrá una solución a corto plazo, ya que el tamaño de la red es tan grande que no es de extrañar que las autoridades de directorio se vean colapsadas por la cantidad de peticiones que reciben en picos puntuales del día, así que lo mejor que podéis hacer si navegáis por la web profunda de TOR es respirar profundo y llenaros de mucha paciencia.

Sin embargo no todo en TOR son problemas, eso está claro, ya que sino tuviera las virtudes que tiene nadie la usaría. Una de esas virtudes es la cantidad de usuarios que aportan a la red y el número de personas que crean herramientas, librerías, sitios con documentación, etc. Son aportes que ayudan a todo el ecosistema de la red y que desde luego le han permitido estar en la posición en la que está actualmente. No obstante, existen otras redes anónimas que si bien llevan prácticamente el mismo tiempo de desarrollo que TOR (entre los años 2003 y 2005) no han tenido las repercusiones ni el impacto que ha tenido TOR. Tal es el caso de redes como I2P y FreeNet, siendo la primera la que desde mi punto de vista puede aportar una solución elegante y eficiente a los problemas que he descrito anteriormente en TOR. Seguramente te preguntaras ¿Y por qué I2P no es tan conocido si es tan bueno? Francamente no me lo explico, pero desde mi punto de vista es una cuestión de propaganda y moda, algo que desafortunadamente mueve muchas cosas en la industria de la seguridad y en la informática en general. Creo que I2P no ha llegado a recibir el reconocimiento que se merece porque en los medios solamente se habla de TOR, es el referente de anonimato por excelencia a cualquiera que se lo preguntes! lo cual es una pena. Por ese motivo me he animado a escribir este articulo, hablando de las desventajas que tiene TOR y como una red como I2P puede aportar una solución real.

- Red descentralizada. Ya no hablamos de autoridades de directorio, hablamos de máquinas que se conectan a una red privada en la que todos “hablan el mismo idioma” y no existen entidades que gobiernen el funcionamiento general de la red. Tu te conectas y automáticamente ya eres parte de la red, no necesitas descargarte ficheros con información sobre la red o cosas similares, todos los usuarios son repetidores potenciales y están ahí para construir tus propios túneles de comunicación con otros usuarios. Se acabo eso de depender de 1 o 10 ordenadores para poder navegar en la web profunda o para construir circuitos.

- ¿Buenas intenciones? De eso nada, todos juegan con las mismas reglas. A diferencia de TOR, en I2P no se ruega a nadie que por favor aporte un poco de su ancho de banda y que convierta su instancia de I2P en un repetidor para los circuitos de los usuarios. No, en I2P todos los usuarios que se conectan actúan como repetidores. Esto quiere decir que si te conectas a I2P, una parte de tu ancho de banda será utilizada por otros usuarios en la red, eso si, tu puedes decidir cuanto puedes o quieres aportar. Esto es una característica que en mi opinión es de las más acertadas, ya que hace que los ataques “sybil” sean prácticamente inviables.

- Circuitos en doble sentido y túneles unidireccionales En TOR los túneles que construyen los clientes están compuestos por tres máquinas y dichas máquinas se utilizan para enviar y recibir información. En I2P esto también cambia, ya que no existen los circuitos como tal, en su lugar se crean túneles de comunicación en un solo sentido. Si un emisor quiere enviar un mensaje a un destinatario contará con un túnel compuesto por “x” repetidores que se encargarán de enviar el mensaje y por otro lado, si el emisor quiere recibir mensajes provenientes de la red, contará con otro túnel compuesto por “z” repetidores que se encargarán de recibir el mensaje y enrutarlo. Este modelo es simplemente genial, ya que los túneles pueden contar con un número configurable de repetidores y solamente se encargan de una única tarea que es enviar o recibir datos. Este modelo no solamente dificulta los ataques de análisis de trafico, sino también los ataques de correlación, ya que los túneles de entrada y salida no guardan ningún tipo de relación entre ellos, son completamente independientes y solamente la instancia que ha construido sus túneles sabe cuales son las máquinas que se utilizan para enviar y recibir datos. Por otro lado, a diferencia TOR, todas la comunicación va cifrada en todos los puntos, desde el principio hasta el final, utilizando un proceso de cifrado que en el mundo de I2P se conoce como cifrado “Garlic”.

- TCP, UDP, ICMP, el protocolo que quieras. En I2P no nos limitamos a utilizar protocolo TCP, podemos utilizar cualquier protocolo de red sin temor a perder nuestro anonimato. Esta característica facilita enormemente las cosas a la hora exponer servicios, ya que no solamente no nos limitamos a protocolos conocidos que utilizan TCP, sino a cualquier protocolo de red como UDP. Esta es otra de las razones por las cuales en I2P es posible implementar servicios P2P y descargar torrents y en TOR no.

- Servicios ocultos. Por fin, mi página carga rápido! Los servicios ocultos en I2P no solamente son más eficientes y rápidos, son muchísimo más ricos en términos de funcionalidades, ya que la arquitectura de I2P permite crear sitios web que permitan la ejecución de aplicaciones web 2.0 con Javascript, HTML5, CSS3 y frameworks para mejorar la experiencia de usuario (vease Dojo, NodeJS, AngularJS, etc) de hecho, I2P cuenta con un sistema de plugins que permite desplegar aplicaciones aplicaciones de forma rápida e intuitiva. Tenemos ante nosotros una amplia gama de alternativas que no existen en TOR, eso sin contar con que dado que la red es completamente descentralizada no existen las demoras y molestos retrasos a la hora de acceder a los servicios ocultos en TOR. I2P es un serio candidato a aquellos que buscan privacidad y niveles fuertes de anonimato. Además, para aquellos como yo, que les gusta ver cómo funcionan este tipo de tecnologías, puede resultar tanto o más interesante que TOR, ya que su arquitectura es tan compleja como genial. Para no terminar este articulo sin un contenido practico que puedas probar en tu ordenador, me gustaría dejar una referencia a algunos artículos que he escrito sobre I2P en este sitio:

http://thehackerway.com/2011/11/28/preservando-el-anonimato-y-extendiendo-su-uso-conceptos-basicos-sobre-el-uso-de-i2p-parte-xxii/

http://thehackerway.com/2011/11/30/preservando-el-anonimato-y-extendiendo-su-uso-conceptos-basicos-sobre-el-uso-de-i2p-parte-xxiii/

http://thehackerway.com/2011/12/02/preservando-el-anonimato-y-extendiendo-su-uso-administracion-de-i2p-aplicaciones-y-servicios-incluidos-parte-xxiv/

http://thehackerway.com/2011/12/05/preservando-el-anonimato-y-extendiendo-su-uso-administracion-de-i2p-aplicaciones-y-servicios-incluidos-parte-xxv/

http://thehackerway.com/2011/12/07/preservando-el-anonimato-y-extendiendo-su-uso-servicios-anonimos-eepsites-y-ssh-en-i2p-parte-xxvi/

http://thehackerway.com/2011/12/09/preservando-el-anonimato-y-extendiendo-su-uso-servicios-anonimos-plugins-en-i2p-parte-xxvii/

http://thehackerway.com/2011/12/12/preservando-el-anonimato-y-extendiendo-su-uso-arquitectura-y-protocolos-utilizados-en-i2p-parte-xxviii/

http://thehackerway.com/2011/12/16/preservando-el-anonimato-y-extendiendo-su-uso-estructura-de-i2p-parte-xxx/

http://thehackerway.com/2011/12/21/preservando-el-anonimato-y-extendiendo-su-uso-hacking-i2p-desarrollo-de-aplicaciones-usando-streaming-library-parte-xxxii/

http://thehackerway.com/2012/01/18/preservando-el-anonimato-y-extendiendo-su-uso-hacking-i2p-desarrollo-de-aplicaciones-usando-bob-parte-xxxiii/

Si bien es cierto que son artículos que he escrito hace un poco más de 3 años, siguen teniendo vigencia y son bastante útiles para entender en detalle el funcionamiento de I2P. Finalmente, no creas nada de lo que he dicho, ve y compruébalo por ti mismo!. La invitación es clara, es el momento de comenzar a utilizar I2P y conocer de primera mano los beneficios que nos puede aportar.

Un saludo y Happy Hack! Adastra.

Instalación de un proxy TOR2WEB para acceder a servicios ocultos desde Internet

enero 22, 2015 Deja un comentario

Seguramente muchos de los que leéis este blog y os interesan temas relacionados con el anonimato, TOR y cosas similares, conocéis el proyecto “TOR2WEB”, pero para los que no, basta con decir que es una plataforma creada por el equipo de TOR que permite que los servicios ocultos que se publican internamente en la web profunda de TOR se encuentren disponibles desde Internet sin necesidad de que el cliente tenga que arrancar una instancia de TOR en su máquina. Esto quiere decir que cualquier usuario corriente en internet, utilizando cualquier navegador web, podrá acceder a un servicio oculto muy fácilmente.

TOR2WEB está diseñado para funcionar como un proxy reverso, que solamente se encarga de enrutar todas las peticiones entrantes desde la “clear web” a la “deep web” de TOR, con lo cual los servicios ocultos siguen siendo ocultos, incluso para un proxy TOR2WEB. No obstante, el cliente que visita dichos contenidos no lo es, a menos claro, que utilice TOR para acceder a dicho proxy algo que que no tiene mucho sentido, ya que al utilizar TOR ya se tiene acceso a la web profunda de TOR y realmente no seria necesario utilizar TOR2WEB.

“tor2web.org” está conformado por voluntarios en todo el mundo que configuran y exponen un servicio de TOR2WEB para que cualquier usuario en Internet pueda utilizarlo. Dado que se trata de un proxy, no almacena los contenidos de los sitios ocultos, simplemente se encarga de enrutar las peticiones entre la web profunda de TOR y la “web clara”.

Acceder a un servicio oculto en la web profunda de TOR es simple, solamente hace falta sustituir la cadena “.onion” de la dirección del servicio oculto por “.tor2web.org”.

Por ejemplo, si la dirección onion de un servicio oculto es la siguiente: “ajio7mfsscpvgd23.onion” la dirección que se debe utilizar para acceder a dicho servicio utilizando TOR2WEB es: “ajio7mfsscpvgd23.tor2web.org”.

Lo primero que verá el usuario cuando navega hacia dicho sitio es una nota legal que indica que TOR2WEB es solamente un servicio de proxy que tira de la web profunda de TOR y que los contenidos que el usuario visualizará son responsabilidad del creador del servicio oculto al que se intenta acceder. Si el usuario está de acuerdo con los términos expuestos por el proxy, puede continuar y acceder a los contenidos del servicio oculto. La siguiente imagen enseña enseña dicha advertencia.

tor2web1

 

Por otro lado, la plataforma también almacena unas estadísticas básicas sobre el número de accesos que ha tenido el servicio oculto el día anterior, por cuestiones de privacidad y para no generar registros sobre el uso de un servicio oculto, solamente se pueden ver las estadísticas del día anterior y no se almacena nada sobre los datos de otros días. Para acceder a dicha información basta con entrar a la uri “/antanistaticmap/stats/yesterday”. Por ejemplo: “ajio7mfsscpvgd23.tor2web.org/antanistaticmap/stats/yesterday”.
Como se ha mencionado anteriormente, TOR2WEB es un servicio que se encuentra soportado por varios voluntarios en Internet, los cuales configuran una instancia del proxy de TOR2WEB con un dominio propio o con el dominio de TOR2WEB.

Aunque el procedimiento de instalación de un nodo de TOR2WEB es una tarea que se encuentra documentada y bastante bien explicada en la documentación oficial del proyecto, en este artículo explicaré en detalle cómo se puede instalar, configurar y arrancar un nodo de TOR2WEB.

Instalación y configuración de un nodo de TOR2WEB

Antes que nada, el proyecto se encuentra alojado en la siguiente URL: https://github.com/globaleaks/Tor2web-3.0 y se recomienda navegar un poco por cada una de las secciones de la documentación para tener una idea más global del funcionamiento de Tor2Web. En primer lugar es necesario instalar el proyecto y dado que se encuentra pensado principalmente para plataformas basadas en Debian, el mecanismo de instalación consiste adicionar un repositorio a la lista del sistema y posteriormente ejecutar el comando “apt-get” o “aptitute”. Existe un script de instalación que se encarga de realizar todas estas tareas de forma automática y que se recomienda utilizar.

>wget https://raw.githubusercontent.com/globaleaks/Tor2web-3.0/master/scripts/install.sh

>chmod +x install.sh

>./install.sh

Cuando se ejecuta el script pide permisos de administrador para instalar el programa utilizando “apt-get”. Después de realizar la instalación, automáticamente se crea el directorio “/home/tor2web/certs” que es donde se deberán crear los certificados y las claves para el proxy.
Se deben ejecutar los siguientes comandos dentro de dicho directorio.

>openssl genrsa -out tor2web-key.pem 4096

>openssl req -new -key tor2web-key.pem -out tor2web-csr.pem

>openssl x509 -req -days 365 -in tor2web-csr.pem -signkey tor2web-key.pem -out tor2web-intermediate.pem

>openssl dhparam -out tor2web-dh.pem 2048

 

Con los pasos anteriores se encuentra casi terminada la instalación, sin embargo antes de poder arrancar el servicio, es necesario crear un fichero de configuración en “/etc/tor2web.conf”. Dicho fichero no existe por defecto, pero después de instalar Tor2Web, se crea automáticamente un fichero de configuración que sirve de ejemplo en “/etc/tor2web.conf.example”. Las propiedades de configuración que incluye el fichero permiten activar o desactivar varias características interesantes de TOR2WEB, sin embargo, las siguientes son las mínimas que se deben de incluir en el fichero de configuración antes de iniciar el servicio.

nodename: Identificador único del servicio. Es bastante útil para identificar las trazas que se envían a los administradores de TOR2WEB.

datadir: Directorio donde se encuentran los ficheros necesarios para el correcto funcionamiento del programa, incluyendo los certificados creados anteriormente.

processes y requests_per_process: Propiedades que permiten ejecutar el programa utilizando multiproceso. El valor recomendado para la propiedad “processes” es el número de cores del sistema +1.

basehost: Se trata del dominio base donde se ejecutará el proxy. TOR2WEB se puede desplegar en un dominio independiente al de tor2web y en tal caso, es necesario especificar dicho dominio en esta propiedad.

listen_port_http y listen_port_https: Puertos HTTP y HTTPS que serán utilizados por el proxy. Evidentemente los valores por defecto son 80 y 443 respectivamente.

sockshost y socksport: Son probablemente las propiedades más importantes, ya que permiten definir el host y el puerto en el que se encuentra en ejecución un proxy SOCKS de TOR. Es evidente la importancia de dichos valores, ya que TOR2WEB utilizará dicho proxy SOCKS para conectarse con la web profunda de TOR y devolver al usuario final los contenidos del servicio oculto que ha solicitado. En este sentido, para lanzar un nodo de TOR2WEB, es necesario tener una instancia de TOR levantada.

ssl_key, ssl_cert y ssl_dh: Se trata de propiedades que permiten especificar la ruta completa de los certificados y la clave privada que se han creado anteriormente para el servicio.

Con las propiedades anteriores se puede comenzar a utilizar TOR2WEB, sin embargo existen otras propiedades que habilitan características especiales del programa, por ejemplo la posibilidad de bloquear servicios ocultos con contenidos inapropiados, bloquear crawlers, sobre-escribir el fichero “robots.txt” y otras cosas que intentan “alejar” el contenido de servicios ocultos de buscadores como google.

Para conocer en mayor detalle todas las opciones de configuración disponibles, se recomienda revisar la documentación en la siguiente sección. https://github.com/globaleaks/Tor2web-3.0/wiki/Configuration-Guide
Para iniciar un nodo de TOR2WEB con la configuración mínima, se puede utilizar el siguiente fichero

[main]
nodename = AdastraTORY
datadir = /home/tor2web
processes = 5
requests_per_process = 100000
listen_port_http = 80
listen_port_https = 443
basehost = tor2web.org
sockshost = 127.0.0.1
socksport = 9150
ssl_key = /home/tor2web/certs/tor2web-key.pem
ssl_cert = /home/tor2web/certs/tor2web-intermediate.pem
ssl_dh = /home/tor2web/certs/tor2web-dh.pem
cipher_list = ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA:DHE-DSS-AES256-SHA:DHE-RSA-AES128-SHA:DES-CBC3-SHA
ssl_tofu_cache_size = 100

 

Con el fichero anterior ubicado en “/etc/tor2web.conf” ahora es posible iniciar el servicio como cualquier otro del sistema

>sudo /etc/init.d/tor2web start
Enabling Tor2web Apparmor Sandboxing
* Starting Tor2web tor2web…
* Starting tor daemon… [ OK ]
>

Con los pasos anteriores, ahora ya contamos con una instancia en ejecución de TOR2WEB en local y disponible para desplegar en algún servidor en Internet.

Saludos y Happy Hack!
Adastra.

Creando sitios ocultos en TOR de forma programática con TxTorCon

diciembre 4, 2014 1 comentario

Anteriormente he hablado sobre el uso de Stem para controlar instancias de TOR, una potente librería que no solamente se aprovecha del protocolo de control de TOR para la administración remota de una instancia en ejecución, sino que también cuenta con algunas utilidades para arrancar una nueva instancia con configuración personalizada, descargar y parsear los descriptores emitidos por las autoridades de directorio, entre muchas otras funcionalidades útiles. Es una librería que se explota bastante bien en Tortazo, una de las herramientas que he escrito para realizar pruebas de penetración contra repetidores de salida y servicios ocultos en la red de TOR.
Aunque Stem es una librería muy potente, existen otras alternativas que cuentan con las mismas capacidades y en esta ocasión, voy a hablar sobre TXTORCON.

¿Por qué TxTorCon? Porqué se trata de una implementación del protocolo de control de TOR basada en Twisted y a diferencia de Stem, TxTorCon es una implementación asíncrona. Una librería como TxTorCon permitirá crear programas reactivos que se encargarán de ejecutar acciones sobre una o varias instancias de TOR ante una lista de eventos predefinidos.

En esta entrada se verá cómo se puede utilizar TxTorCon para crear servicios ocultos en TOR de forma programática y aunque lo que se verá a continuación también se puede hacer con Stem, se trata de un ejercicio practico muy interesante que servirá para conocer los elementos básicos y la “metodología” que se debe seguir cuando se programa con esta librería.

Antes de continuar, se recomienda al lector tener claros los conceptos básicos sobre la configuración de una instancia de TOR y conocer bastante bien las propiedades admitidas en el fichero “torrc”, aunque crear un servicio oculto no es una tarea compleja ya que solamente es necesario definir la opción de configuración “HiddenService” en el fichero de configuración “torrc” tantas veces como servicios ocultos se desee crear, lo que si que puede ser complicado es mantener el servicio oculto correctamente securizado, pero eso es un tema del que se hablará en un próximo artículo.

En primer lugar, es importante conocer el uso de la clase “txtorcon.TorConfig” ya que en dicha clase es donde definen todos los elementos de configuración de una instancia de TOR y dicho elemento puede ser utilizado para levantar la instancia de forma programática utilizando TxTorCon.

import txtorcon
config = txtorcon.TorConfig()
config.SOCKSPort = 9051
config.ORPort = 4443
…..
config.save()

La clase “txtorcon.TorConfig” maneja un diccionario interno con las propiedades que se pueden definir en un fichero de configuración de TOR, con lo cual el programador debe definir cada propiedad como un atributo de instancia.

Ahora bien, para definir uno o varios servicios ocultos, es necesario crear un listado de instancias de la clase “txtorcon.HiddenService”. Dicho listado se almacenará en la variable “HiddenServices” de la instancia de “txtorcon.TorConfig” creada previamente.
La siguiente función servirá para definir los detalles de configuración básicos para iniciar una instancia de TOR con un servicio oculto.

import txtorcon
import functools
import tempfile
import os
from twisted.internet import reactor 

def createTemporal():
    tempDir = tempfile.mkdtemp(prefix='torhiddenservice')
    reactor.addSystemEventTrigger('before', 'shutdown',
functools.partial(txtorcon.util.delete_file_or_tree, tempDir))
    return tempDir 

def configuration(hiddenserviceDir, serviceInterface,
servicePort=8080, hiddenservicePort=80):
    if hiddenserviceDir is None:
        print "[+] HiddenServiceDir not specified... Generating
a temporal file."
        hiddenserviceDir = createTemporal()
    if os.path.exists(hiddenserviceDir) == False:
        print "[+] The HiddenServiceDir specified does not
exists... Generating a temporal file."
        hiddenserviceDir = createTemporal()
    config = txtorcon.TorConfig()
    config.SOCKSPort = 9051
    config.ORPort = 4443
    config.HiddenServices = [txtorcon.HiddenService(config,
hiddenserviceDir, ["%s %s:%s" %(str(hiddenservicePort),
serviceInterface, str(servicePort))] )]
    config.save()
    return config 

configuration('/home/adastra/Escritorio/django-hiddenservice',
'127.0.0.1')

La función “configuration” se encarga de recibir como argumento todos los elementos necesarios para establecer un servicio oculto en la configuración definida en el objeto “txtorcon.TorConfig” y posteriormente dicho objeto es retornado. Por otro lado, la función “createTemporal” es invocada internamente por la función “configuration” con el fin de devolver un directorio temporal para el servicio oculto en el caso de que el directorio indicado por parámetro sea invalido.

Ahora que la configuración se encuentra preparada, el siguiente paso consiste en utilizarla para iniciar la instancia de TOR en cuestión.

import txtorcon
import functools
import tempfile
import os
from twisted.internet import reactor 

def createTemporal():
    tempDir = tempfile.mkdtemp(prefix='torhiddenservice')
    reactor.addSystemEventTrigger('before', 'shutdown',
functools.partial(txtorcon.util.delete_file_or_tree, tempDir))
    return tempDir 

def configuration(hiddenserviceDir, serviceInterface,
servicePort=8080, hiddenservicePort=80):
    if hiddenserviceDir is None:
        print "[+] HiddenServiceDir not specified... Generating a temporal file."
        hiddenserviceDir = createTemporal()
    if os.path.exists(hiddenserviceDir) == False:
        print "[+] The HiddenServiceDir specified does not exists... Generating a temporal file."
        hiddenserviceDir = createTemporal()
    config = txtorcon.TorConfig()
    config.SOCKSPort = 9051
    config.ORPort = 4443
    config.HiddenServices = [txtorcon.HiddenService(config,hiddenserviceDir, ["%s %s:%s" %(str(hiddenservicePort),serviceInterface, str(servicePort))] )]
    config.save()
    return config 

def updates(prog, tag, summary):
    print "%d%%: %s" % (prog, summary) 

def setup_complete(config, proto):
    print "TOR Instance started!" 

def setup_failed(arg):
    print "SETUP FAILED", arg
    reactor.stop() 

def startTor(config):
    d = txtorcon.launch_tor(config, reactor,progress_updates=updates)
    d.addCallback(functools.partial(setup_complete, config))
    d.addErrback(setup_failed)
    reactor.run()
torrc = configuration('/home/adastra/Escritorio/hidden_service_django','127.0.0.1')
startTor(torrc)

En esta nueva versión del script se ha incorporado la función “startTor”, la cual se encarga de utilizar la configuración retornada por la función “configuration” para iniciar TOR. Como se puede apreciar, dicha función emplea la utilidad “txtorcon.launch_tor” enviando como argumentos, la configuración de TOR, el reactor de Twisted y una función de callback para procesar cada uno de los eventos producidos durante proceso de inicio. Finalmente, se adicionan dos funciones más en el caso de que el proceso de arranque haya ido bien o en el caso de fallo.

Después de ejecutar el script anterior, se podrá ver por consola algo muy similar a lo que se enseña en la siguiente imagen.

txtorcon1

El script puede parecer complejo pero tal como se ha explicado anteriormente, si se conoce el funcionamiento de Twisted y las funcionalidades básicas de TxTorCon, no resulta tan complicado de comprender.
Hasta este punto se asume que en la máquina local se encuentra un servicio levantado y esperando conexiones, más concretamente en el puerto “8080”. Evidentemente, dado el escenario anterior es necesario levantar un servidor web con Tomcat, una aplicación con Django o cualquier otro servicio en dicho puerto, pero dadas las características de Twisted, también es posible crear un servidor web simple directamente desde el script y de esta forma, se contará con una herramienta completamente funcional que puede levantar un servicio oculto sin depender de ningún programa externo (excepto el propio ejecutable de TOR).

import txtorcon
import functools
import tempfile
import os
from twisted.web import static, resource, server
from twisted.internet import reactor
from twisted.internet.endpoints import TCP4ServerEndpoint 

def createTemporal():
    tempDir = tempfile.mkdtemp(prefix='torhiddenservice')
    reactor.addSystemEventTrigger('before', 'shutdown',
functools.partial(txtorcon.util.delete_file_or_tree, tempDir))
    return tempDir 

def configuration(hiddenserviceDir, serviceInterface,
servicePort=8080, hiddenservicePort=80):
    if hiddenserviceDir is None:
        print "[+] HiddenServiceDir not specified... Generating a temporal file."
        hiddenserviceDir = createTemporal()
    if os.path.exists(hiddenserviceDir) == False:
        print "[+] The HiddenServiceDir specified does not exists... Generating a temporal file."
        hiddenserviceDir = createTemporal()
    config = txtorcon.TorConfig()
    config.SOCKSPort = 9051
    config.ORPort = 4443
    config.HiddenServices = [txtorcon.HiddenService(config,hiddenserviceDir, ["%s %s:%s" %(str(hiddenservicePort),serviceInterface, str(servicePort))] )]
    config.save()
    return config 

def updates(prog, tag, summary):
    print "%d%%: %s" % (prog, summary) 

def setup_complete(config, proto):
    print "TOR Instance started!" 

def setup_failed(arg):
    print "SETUP FAILED", arg
    reactor.stop() 

def startTor(config):
    #Starting a simple web site.
    root = static.File('/opt/WebSite')
    site = server.Site(root)
    hs_endpoint = TCP4ServerEndpoint(reactor, 8080,interface='127.0.0.1')
    hs_endpoint.listen(site)
    d = txtorcon.launch_tor(config, reactor,progress_updates=updates)
    d.addCallback(functools.partial(setup_complete, config))
    d.addErrback(setup_failed)
    reactor.run() 

torrc =configuration('/home/adastra/Escritorio/django-hiddenservice','127.0.0.1')
startTor(torrc)

El programa anterior solamente añade los elementos necesarios para declarar un servidor web cuyo directorio raíz es “/opt/WebSite”. Dicho servidor web se levantará en el puerto 8080 en la interfaz de red local, tal como se ha definido en la configuración del servicio oculto. Con todo esto, después de que la instancia de TOR se levante y se creen los ficheros correspondientes al dominio “onion” y a las claves del servicio, cualquier cliente que intente ingresar por dicha la dirección onion del servicio oculto, podrá ver los contenidos del servidor web que se ha iniciado utilizando Twisted. La siguiente imagen enseña algo muy similar a lo que el usuario final verá en su navegador.

txtorcon2

Como se puede apreciar, al acceder a la dirección onion del servicio oculto, se pueden visualizar los contenidos del directorio “/opt/WebSite”, que es el directorio que se ha indicado como raíz del servidor web.

Aunque aquí se ha enseñado como crear un servicio web en la red de TOR, también es posible crear cualquier otro tipo de servicio siguiendo exactamente la misma dinámica que se ha explicado aquí, como por ejemplo por un servidor SSH/SFTP con Paramiko, un servidor FTP o incluso un servidor SMB. Tienes a tu disposición muchas alternativas a la hora de automatizar la creación de servicios ocultos en la web profunda de TOR.

Un Saludo y Happy Hack!

Crea tu propia red privada de TOR – Emulación de TOR con Chutney

noviembre 20, 2014 4 comentarios

Somos muchos los que nos interesa saber cómo funciona TOR, pero también somos muchos los que sabemos que existen varios riesgos cuando entramos a ese tipo de redes cuando lo único que queremos es hacer pruebas, por ese motivo, una buena forma de comprender el funcionamiento de todos los elementos que conforman TOR, sin acceder directamente a la red, es por medio de herramientas y librerías que permiten simular y/o emular la red.
En primer lugar, es necesario entender la diferencia entre simular y emular, ambos términos a veces suelen utilizarse como si se tratase de sinónimos, pero no son lo mismo. Cuando simulamos un sistema, contamos con modelo muy especifico que aplica a un contexto particular, por ejemplo, podemos simular el rendimiento midiendo los tiempos de respuesta y haciendo estimaciones sobre su comportamiento con una mayor carga o con más o menos recursos, es decir, una simulación es un mecanismo que permite modelar un sistema en unas condiciones determinadas y es muy útil para hacer estimaciones. Por otro lado, cuando se habla de emular, se duplica el sistema y se ejecuta de forma independiente al sistema original, es decir, se produce una replica del sistema y se puede observar y analizar su comportamiento, dando resultados mucho más exactos que los que puede proporcionar una simulación.
Ahora bien, las simulaciones y emulaciones son términos que seguramente resultarán bastante conocidos y utilizados a los administradores de sistemas y redes, ya que existen varias herramientas que emplean ambos mecanismos para medir los limites de un sistema o el número de clientes concurrentes que pueden estar conectados a una red sin deteriorar su rendimiento. En este sentido, es posible utilizar algunas de estas mismas herramientas para probar el funcionamiento de TOR sin necesidad de conectarse directamente a las autoridades de directorio oficiales. El objetivo de este articulo y el siguiente, es enseñar el uso de dos herramientas que son recomendadas por el equipo de TOR para hacer pruebas sobre la red, dichas herramientas son Chutney y Shadow, la primera es una herramienta de emulación y la segunda de simulación. En esta entrada nos centraremos en Chutney y en la próxima se hablará sobre Shadow.

Instalación y uso de Chutney

Chutney es una herramienta que permite emular y configurar una red privada con TOR muy rápidamente, permitiendo crear varios escenarios en los que Chutney es capaz de levantar autoridades de directorio, repetidores, clientes, bridges y cualquier elemento adicional que conforma la red de TOR. Usar Chutney no es complicado, de hecho es una herramienta bastante sencilla e intuitiva, pero para configurar escenarios de prueba, es necesario conocer bastante bien las propiedades de configuración que admite TOR, es decir, aquellas que típicamente se incluyen en el fichero de configuración “torrc”.
El proyecto se encuentra ubicado en la siguiente ruta: https://gitweb.torproject.org/chutney.git y para comenzar a usarlo, basta con clonar el repositorio GIT y lanzar la utilidad “chutney”

>git clone https://git.torproject.org/chutney.git
Clonar en «chutney»…
remote: Counting objects: 364, done.
remote: Compressing objects: 100% (170/170), done.
remote: Total 364 (delta 180), reused 282 (delta 137)
Receiving objects: 100% (364/364), 58.68 KiB | 0 bytes/s, done.
Resolving deltas: 100% (180/180), done.
Checking connectivity… hecho.
>cd chutney
>./chutney
Error: Not enough arguments given.
Usage: chutney {command} {networkfile}
Known commands are: configure hup restart start status stop verify

Para ejecutar “chutney” se debe indicar un comando y un fichero de configuración de red. Los comandos disponibles son “configure”, “hup”, “restart”, “start”, “status”, “stop” y “verify”. Además, se debe indicar la ruta del fichero de configuración de red como segundo argumento del comando.

Para que la herramienta funcione correctamente, el comando “tor” debe ser un comando valido para el usuario que lo ejecuta, es decir, que TOR se debe encontrar instalado en el sistema y el usuario en cuestión debe de tener los privilegios suficientes para poder ejecutarlo, de lo contrario, “chutney” enseñará el siguiente mensaje.

>./chutney configure networks/basic
Starting nodes
Cannot find tor binary ‘tor’. Use CHUTNEY_TOR environment variable to set the path, or put the binary into $PATH.

Basta con establecer la ruta donde se encuentra el ejecutable en la variable de entorno PATH.

>nano /home/adastra/.bashrc
export PATH=”$PATH:/TOR/tor-browser_40/Browser/TorBrowser/Tor/tor”
>source ~/.bashrc

Si TOR se ha instalado desde algún repositorio de Debian, CentOS o Fedora, no debería haber mayores problemas, sin embargo se recomienda instalar la última versión de TOR disponible, preferiblemente desde el código fuente.

Después de tener todos los elementos instalados y listos para ser utilizados, el primer paso en la puesta en marcha de “chutney” es invocar al comando “configure” para crear todos los directorios y las claves necesarias para instanciar las autoridades de directorio en la máquina donde se ejecuta la herramienta. Dicho comando se debe ejecutar sobre un directorio de configuración de red y en este caso, “chutney” cuenta con algunos ficheros de ejemplo que pueden ser útiles para probar la herramienta. Dichos ficheros se encuentran incluidos en el directorio “networks”.
Cuando se ejecuta el comando “configure”, la herramienta se encarga de crear automáticamente el directorio “net”, el cual incluye todos los elementos necesarios para emular la red de TOR.

>./chutney configure networks/basic
Creating identity key /chutney/net/nodes/000a/keys/authority_identity_key for test000a with tor-gencert –create-identity-key –passphrase-fd 0 -i /chutney/net/nodes/000a/keys/authority_identity_key -s /chutney/net/nodes/000a/keys/authority_signing_key -c /chutney/net/nodes/000a/keys/authority_certificate -m 12 -a 127.0.0.1:7000Creating identity key /chutney/net/nodes/001a/keys/authority_identity_key for test001a with tor-gencert –create-identity-key –passphrase-fd 0 -i /chutney/net/nodes/001a/keys/authority_identity_key -s /chutney/net/nodes/001a/keys/authority_signing_key -c /chutney/net/nodes/001a/keys/authority_certificate -m 12 -a 127.0.0.1:7001Creating identity key /chutney/net/nodes/002a/keys/authority_identity_key for test002a with tor-gencert –create-identity-key –passphrase-fd 0 -i /chutney/net/nodes/002a/keys/authority_identity_key -s /chutney/net/nodes/002a/keys/authority_signing_key -c /chutney/net/nodes/002a/keys/authority_certificate -m 12 -a 127.0.0.1:7002The tor binary at ‘tor’ does not support the option in the torrc line:’TestingDirAuthVoteExit *’
The tor binary at ‘tor’ does not support the option in the torrc line:
‘TestingDirAuthVoteExit *’
The tor binary at ‘tor’ does not support the option in the torrc line:
‘TestingDirAuthVoteExit *’

Como se puede apreciar en las últimas líneas, la opción de configuración “TestingDirAuthVoteExit” no se ha encontrado y aunque es posible seguir trabajando con “chutney” sin problemas a pesar de este error, se trata de una propiedad de configuración que se ha incluido a partir de la versión “2.6-alpha” de TOR y a la fecha de redactar este artículo, aun no se encuentra disponible en la versión estable.
Ahora que se encuentra la red privada configurada, se puede controlar con los comandos “start”, “stop” y “status” tal como enseña la siguiente imagen.

chutney

Comandos disponibles en chutney

La configuración básica funciona correctamente y como se puede ver, se han creado una serie de procesos que representan instancias de TOR que se están ejecutando en la máquina local. No obstante, no se trata de instancias de TOR que se levantan con las propiedades por defecto de TOR Browser, se trata de instancias especialmente configuradas para levantar clientes, autoridades de directorio, repetidores de salida, bridges, etc. En este caso concreto, el contenido del fichero “networks/basic” tiene lo siguiente.

Authority = Node(tag=”a”, authority=1, relay=1, torrc=”authority.tmpl”)
Relay = Node(tag=”r”, relay=1, torrc=”relay.tmpl”)
Client = Node(tag=”c”, torrc=”client.tmpl”)
NODES = Authority.getN(3) + Relay.getN(8) + Client.getN(2)
ConfigureNodes(NODES)

Aunque pueda parecer complejo, esta es la estructura de cualquier fichero de configuración de red de la herramienta y en este caso concreto, se están creando 3 instancias de TOR que actuarán como autoridades de directorio, 8 como repetidores y 2 como clientes, lo que nos da un total de 13 nodos ejecutándose en la máquina local.
La estructura del fichero utiliza la API de “chutney” que se encuentra escrita en Python y cuya clase principal es “Node”, en la que se permite crear una instancia de TOR con características muy concretas y además, cada una de dichas instancias contará con su propio fichero de configuración de TOR (torrc).
Si se mira con atención el fichero de configuración anterior, se puede apreciar que se compone de una serie de instancias de la clase “Node” las cuales son “clonadas” utilizando un patrón “singleton” con el método “getN” en el que se indica el número de instancias que se debe crear. Finalmente, la utilidad “ConfigureNodes” se encarga de configurar todas y cada una de las referencias declaradas.

Configuración personalizada de Chutney

Hasta este punto se ha podido apreciar que configurar “chutney” no es demasiado complejo, sin embargo se ha utilizado una configuración que viene por defecto en el fichero “networks/basic”. Para hacer pruebas un poco más robustas y que posteriormente puedan servir para detectar errores en el funcionamiento de TOR, es necesario aprender a crear ficheros de configuración de red personalizados, algo que tampoco es demasiado complejo si se conocen las principales propiedades que se pueden utilizar en TOR.
En primer lugar, es importante anotar que el constructor de la clase “Node” recibe dos argumentos que identifican la configuración que se debe aplicar en la instancia de TOR, el primero es “tag”, el cual indica si se trata de un repetidor, un cliente, una autoridad de directorio o un bridge y el segundo es el parámetro “torrc”, el cual recibe un nombre de fichero con extensión “tmpl”, el cual representa una plantilla con las propiedades soportadas por TOR.
En el ejemplo anterior, el fichero “networks//basic” ha utilizado las plantillas “authority.tmpl”, “relay.tmpl” y “client.tmpl” y dichas plantillas se encuentran definidas en el directorio “<CHUTNEY_DIR>/templates/”. Para que el lector se haga una idea sobre lo que pueden incluir dichos ficheros, el siguiente es el contenido de la plantilla “authority.tmpl”

${include:relay.tmpl}
AuthoritativeDirectory 1
V3AuthoritativeDirectory 1
ContactInfo auth${nodenum}@test.test
ExitPolicy reject *:*
TestingV3AuthInitialVotingInterval 300
TestingV3AuthInitialVoteDelay 2
TestingV3AuthInitialDistDelay 2
TestingV3AuthVotingStartOffset 0
# Work around situations where the Exit and Guard flags aren’t being set
# These flags are set eventually, but it takes ~30 minutes
# We could be more precise here, but it’s easiest just to vote everything
# Clients are sensible enough to filter out Exits without any exit ports,
# and Guards without ORPorts
# If your tor doesn’t recognise TestingDirAuthVoteExit, update your chutney
# to a version that includes the issue-13161-check-torrc-options features
TestingDirAuthVoteExit *
TestingDirAuthVoteGuard *

Efectivamente, se trata de ficheros muy simples que siguen la misma sintaxis y estructura que el fichero de configuración “torrc”. La única diferencia es que los ficheros plantilla de “chutney” deben incluir una declaración al principio del fichero en el caso de que sea necesario incluir otras plantillas y además, es posible acceder a variables globales “chutney” con “${variable}” tal como se ha visto en el fichero.

Para probar cualquier tipo de configuración es necesario conocer muy bien las propiedades de configuración de TOR y jugar con ellas!
Chutney ya se encarga de crear el entorno por nosotros y emular la red de TOR en nuestro ordenador, con tantas instancias como queramos. Además, como se verá en un próximo artículo, también es posible utilizar Chutney en otras máquinas del segmento de red para tener una emulación mucho más aproximada del comportamiento de TOR, desde un entorno controlado y sin necesidad de estar conectado a Internet.

Herramientas como Chutney son muy utilizadas actualmente por hackers e investigadores con el fin de estudiar el comportamiento de TOR en un entorno aislado para que de esta forma, sea más sencillo encontrar fallos en su implementación sin afectar directamente a la red. Es una herramienta que desde luego es muy recomendada para aquellas personas que quieran probar diferentes configuraciones de TOR en su red local.

Saludos y Happy Hack!

Intentando descubrir hidden services en TOR

octubre 22, 2014 Deja un comentario

En el articulo “ataca un servicio oculto en la red de TOR, si te atreves” he explicado el funcionamiento del protocolo rendesvouz de TOR y las dificultades existentes a la hora de descubrir cualquier tipo de servicio anónimo en TOR. Actualmente, una de las formas más eficientes de atacar la red consiste en intentar controlar la mayor cantidad de repetidores de entrada y salida para posteriormente ejecutar ataques basados en el análisis de las peticiones y los tiempos de las mismas, sin embargo para ello se requieren varios repetidores de TOR controlados y profesionales que sepan aplicar las técnicas de ataque adecuadas, cosas que no suelen estar al alcance de cualquiera. Por otro lado, una de las características intrínsecas de la deep web de TOR, es que no es fácil encontrar cualquier servicio y menos aun si no conoces su dirección onion. Muchas veces, los usuarios de estas redes se dedican a curiosear y a recopilar direcciones que van encontrando en foros, sitios en Internet o en algunos de los buscadores más populares en la web profunda, sin embargo ¿qué pasa con aquellos servicios que son realmente ocultos? Es decir, aquellos servicios cuyas direcciones onion solamente las conocen un grupo muy pequeño de personas y no se encuentran registradas en foros o buscadores. ¿Quiénes suelen crear y usar ese tipo de servicios? Si lo piensas detenidamente, encontrar dichas direcciones es prácticamente imposible, ya que como se ha explicado en el artículo anterior, no es como buscar una aguja en pajar, es más bien como buscar una aguja entre varios billones de agujas aparentemente iguales y sin ningún patrón o perfil que las distinga.

Por otro lado, cuando intentas desarrollar un Framework de auditoria en la deep web de TOR, contar con un repositorio de direcciones onion para poder ejecutar ataques automatizados contra dichos servicios es muy importante y además de contar con un listado de direcciones conocidas (recolectadas de foros, sitios en Internet y buscadores), también es útil contar con mecanismos para intentar descubrir servicios ocultos. Sin embargo aquí, volvemos a lo que ya se ha explicado anteriormente: Manejar el volumen de datos que puede producir el espacio de posibles direcciones onion es simplemente inviable con la capacidad de procesamiento que tienen los ordenadores modernos.

No obstante, a pesar de las dificultades, un atacante puede intentar generar muchas direcciones onion de forma aleatoria o incremental y determinar si en alguna de ellas hay un servicio en ejecución. En este sentido, en Tortazo he implementado algunos mecanismos para generar y procesar direcciones onion, con el fin de intentar descubrir servicios ocultos en la web profunda de TOR.

Estos mecanismos y la estructura que he montado, se explica a continuación.

Modo “Onion Repository” en Tortazo

Es posible generar direcciones Onion validas y posteriormente intentar realizar diferentes tipos de peticiones a dicha dirección, si la conexión es correcta, se asume que hemos encontrado un servicio valido. Ahora bien, pueden haber dos formas de abordar el problema considerando las limitaciones de procesamiento explicadas anteriormente, por un lado puedes intentar generar todas las permutaciones posibles partiendo de una dirección onion parcial con lo cual, entre más conocimiento se tenga sobre la dirección onion (número de caracteres conocidos), mayores serán las probabilidades de encontrar rápidamente el servicio en la web profunda de TOR. Por otro lado, si no tienes información sobre una dirección onion concreta y simplemente quieres consultar cualquier dirección onion sin ningún patrón determinado, Tortazo permitirá generar direcciones onion de forma aleatoria y realizar una conexión para ver si existe algún servicio oculto en ejecución en dicha dirección.

Se trata de dos aproximaciones completamente distintas que pueden ayudar a descubrir servicios ocultos, pero en ambos casos, lo más importante es que la generación y procesamiento de cada dirección onion se haga lo más rápidamente posible, esto con el fin de probar la mayor cantidad de direcciones onion en una franja de tiempo determinada.

En primer lugar, contar con un único proceso para la generación de direcciones y posterior procesamiento (petición contra el servicio) puede ser algo bastante lento, por este motivo, en Tortazo se cuenta con dos colas compartidas, una para las direcciones onion generadas y otra para aquellas direcciones sobre las cuales se ha detectado un servicio oculto en ejecución. Evidentemente, existen dos grupos de procesos, uno de ellos se encarga de la generación de direcciones onion que se insertarán en la cola de direcciones generadas y otro para procesar cada una de dichas direcciones onion y determinar si hay un servicio oculto en ejecución; y si ese es el caso, dicha dirección se insertará en la cola compartida de direcciones con servicios en ejecución.

Puede que suene un poco complejo, a lo mejor con la siguiente imagen queda un poco más claro.

OnionRepository

Para ejecutar Tortazo en modo “repositorio” es necesario especificar la opción “-R” y además, es posible indicar otros detalles como el número de procesos que debe crear la herramienta para el procesamiento y generación de direcciones onion (-W), una dirección onion parcial para generar las direcciones onion de forma incremental (-O <partialAddress>) o generar direcciones onion de forma aleatoria (-O RANDOM).

Algunos ejemplos se pueden ver a continuación:

Generación aleatoria de direcciones onion utilizando 5 procesos para generación y procesamiento de las direcciones creadas. Se realizarán peticiones HTTP contra cada uno de dichos servicios. El programa se ejecutará indefinidamente, hasta que el usuario manualmente decida detenerlo.


python Tortazo.py –R http –O RANDOM –W 5 –v 

 

Generación aleatoria de direcciones onion utilizando 5 procesos para generación y procesamiento de las direcciones creadas. Se realizarán peticiones FTP contra cada uno de dichos servicios. El programa se ejecutará indefinidamente, hasta que el usuario manualmente decida detenerlo.

python Tortazo.py –R ftp –O RANDOM –W 10 –v

 

Generación incremental de direcciones onion utilizando la dirección parcial “sad53kig53r2gha” y 5 procesos para generación y procesamiento de las direcciones creadas. Se realizarán peticiones FTP contra cada uno de dichos servicios. El programa se ejecutará hasta que todas las combinaciones posibles hayan sido probadas, es decir, en este caso concreto, las combinaciones de los dos últimos caracteres de la dirección.

>python Tortazo.py –R ftp –O sad53kig53r2gh –W 10 –v

Generación incremental de direcciones onion utilizando la dirección parcial “sad53kig53r2gha” y 5 procesos para generación y procesamiento de las direcciones creadas. Se realizarán peticiones SSH contra cada uno de dichos servicios. El programa se ejecutará hasta que todas las combinaciones posibles hayan sido probadas, es decir, en este caso concreto, las combinaciones de los dos últimos caracteres de la dirección.

>python Tortazo.py –R ssh –O sad53kig53r2gh –W 10 –v

 

Por otro lado, las direcciones onion sobre las que se ha detectado un servicio oculto en ejecución, se almacenan directamente en base de datos para que puedan ser usadas en alguno de los plugins disponibles en Tortazo. Además, en el proyecto también se incluye un fichero con un listado casi 400 direcciones onion que pueden cargarse (opcionalmente) en la base de datos cuando se arranca el modo “respository” de Tortazo.

Y así funciona el modo repositorio en Tortazo. Actualmente estoy desarrollando varias ideas para ampliar/mejorar el mecanismo de descubrimiento de direcciones onion, sin embargo, será algo que implementaré para la versión 1.2 y cuando sea el momento os hablaré de ello. De momento encontrarás información más detallada en la documentación oficial: http://tortazo.readthedocs.org/en/latest/
Por último, si tienes alguna idea o sugerencia para mejorar, me encantaria que te pusieras en contacto conmigo (debiadastra [at] gmail.com).
Un saludo y Happy Hack!

Hacking con Python Parte 33 – Peticiones HTTP contra TOR utilizando requests y requesocks

septiembre 16, 2014 Deja un comentario

Uso de las librerías requesocks y socks para ejecutar scripts utilizando el proxy socks de TOR.

AnonBrowser.py:    https://github.com/Adastra-thw/pyHacks/blob/master/AnonBrowser.py
SimpleTorConnect.py:   https://github.com/Adastra-thw/pyHacks/blob/master/SimpleTorConnect.py
SimpleTorConnectRequests.py:   https://github.com/Adastra-thw/pyHacks/blob/master/SimpleTorConnectRequests.py

Repositorio GIT de la serie:

https://github.com/Adastra-thw/pyHacks.git


Make a Donation Button

Ataca un servicio oculto en TOR. Si te atreves!

septiembre 5, 2014 6 comentarios

Los servicios ocultos en TOR son una de las características más interesantes que tiene dicha red y sin lugar a dudas, constituyen una forma de compartir información o comunicarse con alguien de forma confidencial y anónima. No obstante suelen ser muy lentos, pesados y a veces, no tienen unos buenos niveles de disponibilidad, además, después del último “advisory” de seguridad publicado por el equipo de TOR https://blog.torproject.org/blog/tor-security-advisory-relay-early-traffic-confirmation-attack muchos han optado por utilizar otras soluciones que suelen dar buenos niveles de anonimato, privacidad, confidencialidad y rendimiento, véase por ejemplo los “freesites” en Freenet o los “eepsites” en I2P. Lo cierto es que en los últimos años la red de TOR se ha convertido en el centro de atención, hay mucho interés de gobiernos y entidades privadas que ven en dicha red, una fuente de información ENORME y todos buscan cualquier tipo de fallo que permita descubrir la identidad de cualquier usuario que utilice TOR.

A pesar de todo, TOR sigue siendo “el rey” en el campo del anonimato y aunque otras redes del mismo tipo tienen características muy similares, aun no llegan al nivel de madurez ni a la cantidad de usuarios que usan TOR. Hablamos de una red muy solida y atacar directamente su infraestructura requiere de una cantidad considerable de servidores para intentar controlar una pequeña fracción de trafico, algo que no suele pasar desapercibido por demasiado tiempo.

Configurar un repetidor o servicio oculto no es demasiado complicado, solamente es necesario establecer las opciones de configuración adecuadas en el fichero “torrc” y a correr. No obstante, hay muchos detalles técnicos que son interesantes y que un hacker/pentester que se dedique a trabajar con esta red debería conocer.

¿Cómo funcionan los servicios ocultos en TOR?

En primer lugar, un servicio oculto puede ser cualquier cosa, desde un servidor HTTP, FTP, SSH, SAMBA, etc. Hablamos de servicios comunes que funcionan utilizando la red de TOR para el envío y recepción de paquetes, el único requisito es que dichos servicios utilicen protocolo TCP o se utilice un “wrapper” para convertir cualquier paquete de datos en otros protocolos como UDP o ICMP directamente a TCP. Como el lector podrá imaginarse, dichos servicios pueden contener fallos de seguridad que pueden ser aprovechados por un atacante y de esta forma, conseguir “romper” su anonimato, aunque suena simple, como se verá más abajo hay ciertos impedimentos que dificultan descubrir y posteriormente atacar servicios vulnerables en la red de TOR.

Evidentemente para que podamos seguir hablando de anonimato y privacidad tanto en el servicio como para sus clientes, la ubicación de ambas partes debe ser desconocida y para ello, TOR emplea el siguiente flujo de trabajo:

Paso 1. El servicio necesita estar disponible en la red de TOR para que los usuarios puedan utilizarlo y para ello, lo primero que hace es elegir tres repetidores en la red de TOR de forma aleatoria y construir un circuito virtual hacia ellos, esto quiere decir que el servicio no establece una conexión directa con dichos repetidores, son simplemente el punto final de los circuitos creados. Estos repetidores elegidos aleatoriamente en la terminología de TOR son conocidos como “Introduction Points” y son los encargados de recibir las peticiones de los clientes y enrutarlas por medio del circuito virtual hacia al servicio oculto. Posteriormente, el servicio oculto se encarga de enviar su clave pública a cada uno de los “Introduction Points”, la cual será utilizada para que cada “Introduction Point” pueda asociar dicha clave pública con un servicio concreto y de esta forma, no exponer en dichos repetidores la ubicación real del servicio.

Paso 2. Hasta este punto, solamente se seleccionan repetidores de forma aleatoria, se crean circuitos virtuales para comunicarse con dichas máquinas y se les envía la clave privada del servicio. No obstante, el servicio oculto debe estar disponible a los clientes y para ello debe registrar su información básica en la red de TOR y de esta forma los clientes podrán acceder a dicho servicio. El servidor debe conformar un “hidden service descriptor” que no es más que un fichero que contiene la dirección “onion” del servicio (se hablará de esto más abajo), su clave pública y el listado de “Introduction Points” seleccionados en el paso anterior. Este descriptor es enviado a las autoridades de directorio de TOR, las cuales se encargan de procesar la solicitud y registrar el servicio oculto.

Paso 3. El servicio está disponible y ahora cualquier usuario podrá acceder a él. No obstante, el cliente TIENE QUE CONOCER la dirección “onion” de ese servicio antes de poder consultarlo a las autoridades de directorio de TOR. Asumiendo que el cliente disponga de dicha dirección “onion”, realiza una petición HTTP a dicha dirección. Dicha petición es tratada de un modo distinto por el protocolo TOR, ya que detecta que se trata de una petición a un servicio oculto y automáticamente se encarga de obtener la información que se encuentra asociada con dicha dirección. En el caso de que dicha dirección se encuentre registrada, el cliente obtendrá la clave pública del servicio y el listado de los repetidores que actúan como “Introduction Point” para contactar con el servicio oculto. El documento que devuelven las autoridades de directorio se conoce como “Rendezvous Service Descriptor”.

Paso 4. Ahora que el cliente tiene todo lo que necesita saber para conectar con el servicio oculto, debe encargarse de crear un circuito a un repetidor concreto que será seleccionado de forma aleatoria y que se encargará de enviar las peticiones del cliente a uno de los “Introduction Point” del servicio oculto. Este repetidor que ha seleccionado el cliente de forma aleatoria se conoce como “Rendezvous Point” y es el encargado de enviar los datos de la petición del cliente junto con la clave pública del servidor para realizar la conexión con alguno de los “Introduction Point” definidos.

Paso 5. La petición inicial del cliente se conoce como “Introduce Message” y se trata de un mensaje cifrado con la clave pública del servicio en el que se indica la ubicación del “Rendezvous Point” junto con una cadena codificada utilizando el mecanismo “one-time-secret” (ver más aquí: http://searchsecurity.techtarget.com/definition/one-time-pad).

Paso 6. Dado que el servicio ahora conoce la ubicación del “Rendezvous Point”, las respuestas a las peticiones del cliente no pasarán por medio de los circuitos creados con los “Introduction Points”, sino que en su lugar, serán enviadas directamente al “Rendezvous Point” el cual usará el circuito establecido con el cliente para encaminar dichas respuestas a su correspondiente destino.

Se trata de un mecanismo que está muy bien pensado, de forma segura se preserva el anonimato y la confidencialidad de los datos. Es simplemente genial. No obstante se sacrifica muchísimo en términos de rendimiento ya que es bastante costosa la construcción de los circuitos involucrados entre el cliente y el servidor. Por este motivo, los hidden services en TOR son lentos. Para que quede un poco más clara la explicación anterior, la siguiente imagen enseña “grosso modo” cómo se establece un servicio oculto en TOR y cómo los clientes acceden a ellos.

 

hiddenservices

 

Hasta este punto ya sabes como funcionan los servicios ocultos en TOR, ahora: ¿Cómo atacar un hidden service y encontrar su ubicación real?. Esa es la gran pregunta y no tiene una respuesta simple, antes habría que responder algunas otras para partir el problema en trozos:

¿Los servicios ocultos pueden contener vulnerabilidades, pero cómo las puedo aprovechar?

Claro que pueden contener vulnerabilidades (y muy gordas) y lo mejor de todo es que es relativamente fácil descubrir y explotar vulnerabilidades en cualquier servicio oculto. Solamente es necesario conocer el servicio oculto que se desea atacar y enrutar cualquier petición que el atacante desea enviar por medio del proxy SOCKS que se levanta en una instancia local de TOR cuando se utiliza la opción de configuración “SocksPort” en el fichero “torrc”. En realidad es un proceso bastante simple, solamente basta con enrutar todas las pruebas que un pentester profesional ejecutaría contra un objetivo determinado utilizando el proxy SOCKS de TOR.

¿Y si es tan fácil, porque los gobiernos y otras organizaciones no lo hacen para atacar servicios ocultos maliciosos?

Atacar un servicio oculto, del que se conoce su dirección “onion” puede ser una tarea “sencilla” (dependiendo de lo bien asegurado que se encuentre el servicio, evidentemente), pero atacar un servicio oculto desconocido, del que no se tiene su correspondiente dirección “onion” es otra cosa.

No se ha mencionado antes, pero las direcciones Onion generadas por TOR, son el resultado de aplicar el algoritmo Base32 sobre el hash SHA de los primeros caracteres de la clave pública del servicio oculto. El algoritmo Base32 generaráun valor codificado de 16 caracteres donde los valores validos son las letras de la “a” a la “z” en minúsculas y los dígitos entre 2 y 7. El resultado de dicha operación es la dirección onion para un servicio oculto y que el usuario debe conocer antes de poder acceder a él. Una vez comprendido lo anterior, una dirección como “ahgt56dr32mhkva1.onion” es teóricamente valida.

¿Es tan difícil obtener todo el listado de direcciones “.onion” en la red de TOR y luego intentar atacar todos los servicios ocultos al estilo “Chuck Norris”?

No solo es difícil, actualmente no hay ordenadores que sean capaces de tratar la cantidad de combinaciones posibles, especialmente cuando los 16 caracteres que conforman la dirección Onion son desconocidos para el atacante. Para que el lector comprenda la dificultad que implica intentar encontrar un servicio oculto, vamos a jugar un poco con los números y vamos a realizar algunos cálculos.

Sabemos que una dirección Onion se compone de 16 caracteres, donde los posibles valores de cada uno de esos 16 caracteres puede variar entre las letras de la “a” y “z” y los dígitos entre 2 y 7. Esto quiere decir, que para calcular el conjunto de direcciones, es necesario realizar un producto cartesiano https://es.wikipedia.org/wiki/Producto_cartesiano dónde el número de posibles combinaciones es: 32^16 = 1208925819614629174706176

Se trata de un valor ENORME y ahora, solamente por un segundo, imagina ese número de posibles combinaciones cargadas en la memoria de un programa para después intentar procesarlas. Es simplemente imposible e inviable con la capacidad de computo de los ordenadores modernos.

El espacio de posibles direcciones Onion es tan grande que resulta imposible controlar la totalidad de posibles servicios ocultos que puedan existir en la red de TOR (Eso sin mencionar que muchos no se encuentran activos todo el tiempo, dificultando aun más su detección). Hablamos de un problema que se encuentra relacionado con la capacidad de los ordenadores modernos y aunque se utilice un cluster de super-ordenadores, el problema sigue presente.

Vamos a jugar un poco más con los números, de tal modo que puedas comprender cuánto tiempo seria necesario para completar la tarea de generar y procesar el espacio total de posibles direcciones Onion.

Supongamos que tenemos uno o varios ordenadores que trabajan paralelamente y son capaces de procesar diez millones de posibles combinaciones por segundo, no estaría nada mal, verdad? Pues, abre una calculadora y haz el calculo o el interprete de Python, que también funciona como una calculadora.

>>> 32**16 / (10000000*60*60*24*365)

3833478626L

Estamos hablando de un proceso que puede tardar cerca de 4 billones de años. Ahora seguro que queda claro el porqué resulta tan difícil descubrir servicios ocultos en la red de TOR. Muchos de los servicios ocultos que conocemos, son muy difundidos en múltiples sitios en Internet, como por ejemplo en este blog, en el que encontrarás algunas entradas con direcciones Onion de servicios ocultos interesantes. La realidad es que la gran mayoría de servicios ocultos y especialmente aquellos que tienen contenidos maliciosos que son creados por mafias, traficantes y de otros grupos de delincuentes que pueden ser extremadamente peligrosos, se mantienen en las sombras y tienen un nivel de anonimato bastante alto ya quesus direcciones no las vas a encontrar en blogs, directorios de direcciones onion o cualquier sitio en Internet, son realmente servicios ocultos que un grupo muy limitado de personas conocen y utilizan. Esos servicios, puede que tengan vulnerabilidades que cualquier Hacker podría explotar, pero el punto es: ¿Cómo encontrar servicios con esas características? Es como encontrar una aguja en un pajar, o más concretamente encontrar una aguja entre 1208925819614629174706176 agujas. Resulta prácticamente imposible.

Pero algo se podrá hacer, no?

La realidad es que actualmente es poco lo que se puede hacer desde el punto de vista de un pentester o desarrollador, ya que se trata de un problema relacionado con capacidad y poder de procesamiento de los ordenadores actuales, un problema que probablemente se solucionará en algunos años/décadas con la llegada de los ordenadores cuánticos, los cuales teóricamente, tendrán una capacidad de procesamiento que será muchísimo mayor que varios super-ordenadores juntos, sin embargo para eso aun faltan varios años. Se puede intentar limitar la cantidad de combinaciones reduciendo el número de caracteres empleados para la generación de la dirección Onion, limitando también la cantidad de posibilidades y probablemente descartando una gran cantidad de direcciones con algún servicio en ejecución. Otra posibilidad, es tener el conocimiento de una dirección parcial y de este modo, la cantidad de combinaciones de la dirección onion se reducirá considerablemente. Finalmente, se puede crear un proceso que se ejecutará de manera indefinida e ininterrumpida generando direcciones onion validas de forma aleatoria y posteriormente ejecutar una petición contra dicha dirección con la esperanza de encontrar un servicio oculto, algo similar a pegar tiros al aire esperando darle a algún pato o irte a pescar, sera simplemente cuestión de suerte y puede tardar horas o incluso días en obtener resultados positivos.

No son soluciones que realmente ayuden a resolver el problema, sin embargo permiten acotarlo un poco.

De esto hablaré en una próxima entrada.

Saludos y Happy Hack!

Seguir

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

Únete a otros 1.288 seguidores

A %d blogueros les gusta esto: