dnschef-ng

[!NOTE] Esta é uma versão atualizada de DNSChef originalmente escrito por @iphelix``` _ _ __
| | v0.7 | | / |
| | __ ___ | | | | ______ _ __ __ _ / | '_ \/ __|/ __| '_ \ / _ \ _|______| '_ \ / _ | | (| | | | _ \ (__| | | | __/ | | | | | (| | _,|| ||/_|| ||___|| || ||_, | / | |_/ D O C U M E N T A T I O N

O DNSChef é um proxy DNS altamente configurável para Testadores de Penetração e Analistas de Malware. Um proxy DNS (também conhecido como "Fake DNS") é uma ferramenta usada para análise de tráfego de rede de aplicativos, entre outros usos. Por exemplo, um proxy DNS pode ser usado para falsificar requisições para "badguy.com" e apontá-las para uma máquina local para terminação ou interceptação em vez de um host real em algum lugar da Internet.

Existem vários proxies DNS por aí. A maioria simplesmente aponta todas as consultas DNS para um único endereço IP ou implementa apenas filtragem rudimentar. O DNSChef foi desenvolvido como parte de um teste de penetração onde havia a necessidade de um sistema mais configurável. Como resultado, o DNSChef é um aplicativo multiplataforma capaz de forjar respostas com base em listas de domínios inclusivas e exclusivas, suportando vários tipos de registros DNS, correspondência de domínios com curingas, fazendo proxy de respostas reais para domínios não correspondentes, definindo arquivos de configuração externos, IPv6 e muitos outros recursos. Você pode encontrar uma explicação detalhada de cada um dos recursos e usos sugeridos abaixo.

O uso de um proxy DNS é recomendado em situações em que não é possível forçar um aplicativo a usar algum outro servidor proxy diretamente. Por exemplo, alguns aplicativos móveis ignoram completamente as configurações de proxy HTTP do sistema operacional. Nesses casos, o uso de um servidor proxy DNS como o DNSChef permitirá que você engane esse aplicativo para encaminhar conexões ao destino desejado.

## Novos Recursos

- Requer Python 3.11+
- Suporta transferência de arquivos via DNS (somente sobre `A`,`AAAA`,`TXT` por enquanto...)
- O arquivo de configuração agora é TOML
- API HTTP opcional (permite consultar logs e atualizar a configuração remotamente)
- Totalmente assíncrono para maior desempenho (usa AsyncIO)
- Logging estruturado e uma série de melhorias de qualidade de vida
- Agora é um pacote Python
- Dockerizado
- Inclui vários PRs e correções do repositório original

## Instalação

Para instalar a versão mais recente, você deve usar [pipx](https://pypa.github.io/pipx/) (a menos que você seja um merda que gosta de coisas mal feitas):

    pipx install dnschef-ng

Se você quiser a API HTTP (requer algumas dependências extras):
    
    pipx install dnschef-ng[api]

Instale a versão mais recente do Git usando pipx:

     pipx install git+https://github.com/byt3bl33d3r/dnschef-ng.git

Instale a versão mais recente do Git usando pipx com as dependências para a API HTTP:

     pipx install "git+https://github.com/byt3bl33d3r/dnschef-ng.git#egg=dnschef-ng[api]"


## Configurando um Proxy DNS

Antes de começar a usar o DNSChef, você deve configurar sua máquina para usar um servidor de nomes DNS com a ferramenta em execução. Você tem várias opções com base no sistema operacional que vai usar:

- **Linux** - Edite o */etc/resolv.conf* para incluir uma linha no topo com o host de análise de tráfego (por exemplo, adicione "nameserver 127.0.0.1" se estiver rodando localmente). Alternativamente, você pode adicionar um endereço de servidor DNS usando ferramentas como o Network Manager. Dentro do Network Manager, abra as Configurações de IPv4, selecione *Somente endereços (DHCP) automáticos* ou *Manual* no menu suspenso *Método* e edite a caixa de texto *Servidores DNS* para incluir um endereço IP com o DNSChef em execução.

- **Windows** - Selecione *Conexões de Rede* no *Painel de Controle*. Em seguida, selecione uma das conexões (por exemplo, "Conexão Local"), clique com o botão direito nela e selecione Propriedades. Dentro da caixa de diálogo que aparece, selecione *Protocolo IP (TCP/IP)* e clique em Propriedades. Por fim, selecione o botão de opção *Usar os seguintes endereços de servidor DNS* e insira o endereço IP com o DNSChef em execução. Por exemplo, se estiver rodando localmente, insira 127.0.0.1.

- **OS X** - Abra *Preferências do Sistema* e clique no ícone *Rede*. Selecione a interface ativa e preencha o campo *Servidor DNS*. Se estiver usando o Airport, você terá que clicar no botão *Avançado...* e editar os servidores DNS a partir daí. Alternativamente, você pode editar o */etc/resolv.conf* e adicionar um servidor de nomes falso no topo (por exemplo, "nameserver 127.0.0.1").

- **iOS** - Abra *Ajustes* e selecione *Geral*. Em seguida, selecione *Wi-Fi* e clique na seta azul à direita de um Ponto de Acesso ativo na lista. Edite a entrada de DNS para apontar para o host com o DNSChef em execução. Certifique-se de ter desabilitado a interface Celular (se disponível).

- **Android** - Abra *Configurações* e selecione *Sem fio e redes*. Clique em *Configurações de Wi-Fi* e selecione *Avançado* após pressionar o botão *Opções* no telefone. Ative a caixa de seleção *Usar IP estático* e configure um servidor DNS personalizado.

Se você não tiver a capacidade de modificar as configurações de DNS do dispositivo manualmente, ainda terá várias opções envolvendo técnicas como [ARP Spoofing](http://en.wikipedia.org/wiki/ARP_spoofing), [Rogue DHCP](http://www.yersinia.net/doc.htm) e outros métodos criativos.

Por fim, você precisa configurar um serviço falso para onde o DNSChef apontará todas as requisições. Por exemplo, se você está tentando interceptar tráfego web, deve subir um servidor web separado rodando na porta 80 ou configurar um proxy web (por exemplo, Burp) para interceptar o tráfego. O DNSChef apontará as consultas para o seu host de proxy/servidor com serviços devidamente configurados.

## Executando o DNSChef

O DNSChef é um aplicativo multiplataforma desenvolvido em Python que deve ser executado na maioria das plataformas que possuem um interpretador Python. Este guia se concentrará em ambientes Unix; no entanto, todos os exemplos abaixo foram testados e funcionam também no Windows.

Vamos experimentar o DNSChef com sua funcionalidade de monitoramento mais básica. Execute o seguinte comando como root (necessário para iniciar um servidor na porta 53):

    # ./dnschef.py
        
              _                _          __  
             | | version 0.2  | |        / _| 
           __| |_ __  ___  ___| |__   ___| |_ 
          / _` | '_ \/ __|/ __| '_ \ / _ \  _|
         | (_| | | | \__ \ (__| | | |  __/ |  
          \__,_|_| |_|___/\___|_| |_|\___|_|  
                       [email protected]  

    [*] DNSChef started on interface: 127.0.0.1 
    [*] Using the following nameservers: 8.8.8.8
    [*] No parameters were specified. Running in full proxy mode

Sem nenhum parâmetro, o DNSChef rodará em modo proxy completo. Isso significa que todas as requisições serão simplesmente encaminhadas para um servidor DNS upstream (8.8.8.8 por padrão) e retornadas ao host de consulta. Por exemplo, vamos consultar um registro "A" para um domínio e observar os resultados:

    $ host -t A thesprawl.org
    thesprawl.org has address 108.59.3.64

O DNSChef imprimirá a seguinte linha de log mostrando hora, endereço IP de origem, tipo de registro solicitado e, o mais importante, qual nome foi consultado:

    [23:54:03] 127.0.0.1: proxying the response of type 'A' for thesprawl.org

Esse modo é útil para monitoramento simples de aplicativos, quando você precisa descobrir quais domínios o aplicativo usa para suas comunicações.