dns2tcp: ignore portais cativos e navegue na Internet sem limites

É bom lembrar que o DNS protocolo cumpre a função de resolver os nomes de domínio que queremos. Isso é extremamente útil porque, se não existisse, na barra de endereços do navegador, sempre devemos escrever os endereços IP, e isso é praticamente impossível de manter. Neste guia, falaremos especificamente sobre túneis DNS que nos ajudarão a contornar as limitações de acesso, como firewalls e portais cativos.

No entanto, é possível iniciar esses tipos de túneis porque o administrador da rede não fez as definições de configuração apropriadas para bloqueá-lo. Um método prático para saber se podemos realizar o túnel DNS é entrar na linha de comando e executar o seguinte:

nslookup www.google.com

Pressione “Enter” e você verá os dados como na captura compartilhada. Nesse caso, você pode iniciar o túnel DNS. A primeira coisa que precisaremos é de uma ferramenta chamada dns2tcp , essa ferramenta é usada para estabelecer conexões DNS. Precisamente, isso nos ajudará a ignorar qualquer portal cativo configurado em redes públicas.

A principal condição para que a ferramenta funcione corretamente é que a porta 53 UDP esteja habilitada pelo firewall, caso contrário não funcionará e não poderemos escapar do portal cativo ou do firewall. Abaixo, vamos demonstrar o esquema operacional para entender melhor como a barreira do portal cativo é evitada:

• Quando o cliente dns2tcp é iniciado, o recurso seguro SSH é necessário através da porta 2222 usando o protocolo de transporte TCP. Todo o tráfego TCP gerado é mascarado e assume a forma de solicitações de DNS falsas .
• Em seguida, um proxy SOCKS é aberto através da porta 1080.
• Essas solicitações DNS falsas são passadas para o servidor dns2tcp, que é responsável por desmascará-las, e consegue enviá-las ao destino original.
• Quando o destino responde à solicitação, essa resposta passa primeiro pelo servidor dns2tcp para ser encapsulado em um resposta DNS falsa .
• A resposta mascarada é passada para o cliente dns2tcp que a cancela e finalmente a repassa ao usuário

O fim desse esquema é que o usuário pode acessar os sites que deseja.

Inicialização, instalação e configuração do Ubuntu na AWS

Se quisermos colocar isso em prática, precisamos de um servidor que tenha a ferramenta dns2tcp instalada e seu próprio domínio que deve apontar para o IP público do servidor (dns2tcp, também). Podemos usar um computador extra que temos ou usar recursos mais funcionais e econômicos, como um Raspberry Pi. Para o último, poderíamos instalar o Linux distribuição que desejamos, como Raspbian entre outros.

No entanto, optar por hardware adicional representa uma despesa extra. Então, podemos escolher alternativas gratuitas como Amazon Web Services . Neste tutorial, focaremos a parte mais importante da criação do túnel DNS: o servidor em que o dns2tcp está hospedado. Se não tivermos isso, não há como começar.

A primeira coisa que você deve fazer é inserir o AWS portal e crie uma conta gratuita. Você pode acessar várias soluções por um ano sem pagar uma assinatura. Um detalhe importante é que, em uma das etapas, você deve inserir as informações do cartão de crédito, mas não se preocupe, não haverá cobrança. Então vá para Minha Conta e selecione o Console de gerenciamento da AWS opção.

Entre as várias opções que você verá, você escolherá a primeira EC2 Escusado será dizer que, EC2 é gerido pela instâncias . Essas instâncias são como contêineres onde as máquinas virtuais que criamos estão hospedadas. Eles podem ser versões diferentes de Windows Servidor ou servidores Linux. Se você estiver interessado em aprender mais, sugerimos explorar a miríade de opções de virtualização.

Isso nos levará ao painel dedicado ao serviço EC2 e iremos para Instâncias .

Vamos pro azul Instância de lançamento botão

Agora temos um assistente de criação para o nosso instância . Essa é a instância que conterá nosso servidor virtualizado, que por sua vez hospedará a ferramenta dns2tcp.

Nesse caso, escolheremos um Ubuntu servidor e não vamos nos preocupar muito com a versão a ser usada. Desde que estamos apenas testando. Depois clicamos no azul Selecionar botão.

Escolhemos a opção qualificada para uso com o plano gratuito (aquele com o rótulo Nível gratuito qualificado) .

Mais tarde, aparecerão etapas que não precisamos prestar atenção neste momento. No entanto, chegaremos a passo 6 (Segurança Grupos) e adicione uma nova regra que permita a criação de túneis DNS: o DNS protocolo (UDP)

Quando escolhemos essa opção, ela indica automaticamente o número da porta, que é 53. Onde diz Source, podemos indicar a opção Custom e, ao lado, colocamos o IP 0.0.0.0/0 . Então clique Revisar e iniciar .

Uma etapa final de revisão será exibida e você deverá clicar em Apresentação livro . Como veremos abaixo, na realidade, este não é o último passo. O que faremos agora é gerar o par de chaves (que consiste em uma chave pública e uma chave privada) que nos permitirá conectar com segurança à nossa instância que acabamos de criar.

Nesta etapa, você deve selecionar o Crie um novo par de chaves para que ele possa nos fornecer um novo par de chaves. Onde diz Nome do par de chaves , indicamos o nome do par que queremos. Recomendamos o uso de um nome que possamos reconhecer facilmente o arquivo quando o procurarmos. Algo muito importante que indica que o arquivo será gerado por uma única vez; portanto, é conveniente salvá-lo em um local seguro no computador e que possamos lembrar. Então clicamos Download Par de chaves para baixar o arquivo e Instâncias de lançamento

Após alguns minutos, você verificará se o status da instância recém-criada estará pronto para iniciá-la e, portanto, terá acesso ao nosso servidor virtualizado. O destaque em vermelho é o que avisará se você já pode iniciar sua instância. Se aparecer como na captura de exemplo, você poderá iniciar. Você deve selecionar a instância que criou e clicar no ícone Contato botão.

Aparecerá uma janela que lhe dará opções para conectar-se à sua instância. Nesse caso, demonstraremos como conectar-se usando um cliente SSH. Portanto, precisaremos de um programa chamado PuTTY .

Instale o PuTTY em segundos

Para nos conectarmos ao nosso servidor Ubuntu que criamos usando a instância da AWS, precisaremos deste programa. Especificamente dois, PuTTY e PuTTY Gen. Acesse este link e procure pelos dois programas, eles são bastante leves e não exigem muitas etapas de instalação.

Agora vamos para PuTTY Geração , essa ferramenta nos ajudará a converter o arquivo do par de chaves que baixamos quando terminamos de criar nossa instância na AWS. Para ter um contexto de por que fazemos isso, o PuTTY suporta arquivos de pares de chaves em .ppk formato, uma vez que tenhamos feito a conversão, esse arquivo nos ajudará a conectar via SSH ao nosso servidor virtual Ubuntu.

At parâmetros , escolhemos o algoritmo de criptografia RSA usado para SSH-2. No entanto, atualmente é recomendável criar chaves SSH com Ed25519 ou ECDSA, pois são as mais seguras. Então, em Ver , vamos procurar o .pem arquivo que criamos anteriormente na AWS.

Quando queremos abrir o arquivo, verifique se é possível visualizar todos os arquivos e evitar problemas para encontrá-lo. Você abre e, em segundos, verá um aviso de que foi importado com sucesso:

Você clica OK e então você clicará no Salvar chave privada botão, já que esta é a chave que servirá para autenticar você e se conectar ao seu servidor Ubuntu. Você verá um aviso de aviso, mas pode clicar em Sim sem constrangimento, nomeie o arquivo como preferir e salve-o.

Como se conectar ao nosso servidor virtualizado com o PuTTY

Agora, vamos encontrar o programa PuTTY e teremos uma janela como esta

Como mencionamos, vamos conectar usando o protocolo SSH. O que precisamos fazer para evitar repetidamente o próximo passo é conserte nosso chave privada gerada lima de PuTTY Geração para que possamos nos conectar com sucesso sempre que quisermos.

Procuramos o SSH seção que está em Categoria , Em seguida Auth e onde diz Arquivo de chave privada para autenticação nós carregamos nosso .ppk arquivo que acabamos de converter para PuTTY Gen. Voltamos à AWS e procuramos a instância que acabamos de criar, selecione-a e clique em Contato . Mais uma vez, a janela que vimos acima aparece e copiamos as informações mencionadas em step 4 , que é o nosso DNS público.

Nós vamos para PuTTY e no Número da seção, no hostname No campo, colocamos o seguinte:

nombredeusuario@DNSpublico

Ao virtualizar um servidor Ubuntu, no usuário simplesmente escrevemos ubuntu em minúsculas seguido de @ e o DNS público que copiámos antes, sem espaços

ubuntu@dnspublico-ABC-123-dEf

Mantemos o número da porta 22 em Sessões salvas colocamos qualquer nome para gravar nossa conexão com o servidor Ubuntu, clicamos Salvar para gravá-lo e clique em Abra .

Pela primeira vez, você verá um aviso e deverá clicar em Sim :

E pronto, espere alguns segundos para a conexão iniciar e vamos ver uma janela como esta. Temos acesso ao nosso servidor Ubuntu virtualizado!

Depois de criar a máquina virtual na AWS e ter conectividade via SSH, tudo o que precisamos fazer é usar a ferramenta dns2tcp.

Instalação e configuração do dns2tcp no Ubuntu

A primeira coisa que teremos que fazer em nosso Servidor Ubuntu é instalar a ferramenta dns2tcp:

sudo apt install dns2tcp

Uma vez instalado, no cliente e no servidor, teremos que fazer alguns pequenos ajustes.

Configuração e inicie o servidor dns2tcp

Teremos que fazer uma breve configuração editando o arquivo de configuração localizado em /etc/dns2tcp.conf e que contém o seguinte:

root@debian-vm:/home/bron# cat /etc/dns2tcpd.conf
listen = 127.0.0.1
port = 53
# If you change this value, also change the USER variable in /etc/default/dns2tcpd
user = nobody
chroot = /tmp
domain = your.domain.tld
resources = ssh:127.0.0.1:22 , smtp:127.0.0.1:25
root@debian-vm:/home/bron#

Temos que editá-lo da seguinte maneira:


listen = 0.0.0.0
port = 53
# If you change this value, also change the USER variable in /etc/default/dns2tcpd
user = nobody
chroot = /tmp
domain = EL_DOMINIO_DE_AWS
key= redeszone
resources = ssh:127.0.0.1:22 , smtp:127.0.0.1:25
root@debian-vm:/home/bron#

O campo "chave" é opcional, mas é recomendável ter uma autenticação para impedir que alguém se conecte. Devemos executá-lo da seguinte maneira:

root@debian-vm:/home/bron# sudo dns2tcpd -F -d 3 -f /etc/dns2tcpd.conf
18:52:08 : Debug options.c:97 Add resource ssh:127.0.0.1 port 22
18:52:08 : Debug options.c:97 Add resource smtp:127.0.0.1 port 25
18:52:08 : Debug socket.c:55 Listening on 0.0.0.0:53 for domain your.domain.tld
Starting Server v0.5.2...
18:52:08 : Debug main.c:132 Chroot to /tmp
16:52:08 : Debug main.c:142 Change to user nobody

Uma vez feito isso, teríamos apenas que nos conectar com nosso cliente.

Configuração do cliente para conectar-se via dns2tcp

A maneira mais fácil de conectar-se é executar uma linha de comando com tudo o que você precisa, e você pode ver em detalhes qual é a conexão e a criação automática do soquete para SSH na porta 2222.

dns2tcpc -z EL_DOMINIO_DE_AWS -k redeszone -r ssh -l 2222

Agora, podemos fazer a conexão com o SSH da seguinte maneira e a comunicação será criptografada e autenticada:

ssh bron@127.0.0.1 -p 2222 -D 8080

Finalmente, teremos que configurar o PROXY SOCKS em nosso navegador, por exemplo, em Firefox seria o seguinte:

Dessa forma, você poderá pular portais em cativeiro e é possível que eles também tenham firewalls, desde que não possuam blocos específicos que impeçam a execução dessa técnica.