Archivo

Posts Tagged ‘anonimato tor’

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 3 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 5 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!

Hacking con Python Parte 25 – Atacando Repetidores de Salida de TOR

julio 22, 2014 1 comentario

Script que utiliza STEM, Python-Nmap y Shodan para atacar los repetidores que se encuentran registrados en los descriptores publicados por las autoridades de directorio.
Se trata de una versión inicial, que modificaré y extenderé en los proximos días.
Publicaré un post para explicar en que consistiran las caracteristicas que quiero implementar y como utilizarlo.

attackTor: https://github.com/Adastra-thw/pyHacks/blob/master/attackTOR.py

Repositorio GIT de la serie:

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


Make a Donation Button

Hacking con Python Parte 24 – Consulta de descriptores de TOR con Stem

julio 15, 2014 Deja un comentario

Conceptos basicos sobre los descriptores de TOR utilizando la API de STEM.

Repositorio GIT de la serie:

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


Make a Donation Button

Seguir

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

Únete a otros 1.148 seguidores

A %d blogueros les gusta esto: