dnschef-ng

DNSChef è un proxy DNS altamente configurabile per Penetration Tester e Analisti di Malware. Un proxy DNS (noto anche come "Fake DNS") è uno strumento usato per l'analisi del traffico di rete delle applicazioni, tra gli altri usi. Per esempio, un proxy DNS può essere usato per falsificare le richieste per "badguy.com" in modo che puntino a una macchina locale per la terminazione o l'intercettazione, invece che a un host reale da qualche parte su Internet.

Esistono diversi proxy DNS in circolazione. La maggior parte si limita a far puntare tutte le query DNS a un singolo indirizzo IP oppure implementa un filtraggio rudimentale. DNSChef è stato sviluppato nell'ambito di un penetration test in cui serviva un sistema più configurabile. Di conseguenza, DNSChef è un'applicazione cross-platform in grado di falsificare risposte basate su liste di domini inclusive ed esclusive, supporta molteplici tipi di record DNS, corrispondenze di domini con wildcard, l'inoltro delle risposte reali per i domini non corrispondenti, la definizione di file di configurazione esterni, IPv6 e molte altre funzionalità. Puoi trovare una spiegazione dettagliata di ciascuna funzionalità e degli usi suggeriti qui sotto.

L'uso di un proxy DNS è consigliato nelle situazioni in cui non è possibile forzare un'applicazione a usare direttamente qualche altro server proxy. Per esempio, alcune applicazioni mobili ignorano completamente le impostazioni del proxy HTTP del sistema operativo. In questi casi, l'uso di un server proxy DNS come DNSChef ti permetterà di ingannare quell'applicazione in modo che inoltri le connessioni verso la destinazione desiderata.

## Nuove funzionalità

- Richiede Python 3.11+
- Supporta lo staging di file via DNS (per ora solo su `A`,`AAAA`,`TXT`...)
- Il file di configurazione ora è TOML
- API HTTP opzionale (consente di interrogare i log e aggiornare la configurazione da remoto)
- Completamente asincrono per prestazioni migliori (usa AsyncIO)
- Logging strutturato e una serie di miglioramenti alla qualità della vita (QOL)
- Ora è un pacchetto Python
- Dockerizzato
- Include una serie di PR e correzioni dal repository originale

## Installazione

Per installare l'ultima versione dovresti usare [pipx](https://pypa.github.io/pipx/) (a meno che tu non sia un pezzo di merda a cui piacciono le bistecche al sangue):

    pipx install dnschef-ng

Se vuoi l'API HTTP (richiede alcune dipendenze aggiuntive):
    
    pipx install dnschef-ng[api]

Installa l'ultima versione da Git usando pipx:

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

Installa l'ultima versione da Git usando pipx con le dipendenze per l'API HTTP:

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


## Configurazione di un proxy DNS

Prima di poter iniziare a usare DNSChef, devi configurare la tua macchina per usare un nameserver DNS con lo strumento in esecuzione su di esso. Hai diverse opzioni in base al sistema operativo che utilizzerai:

- **Linux** - Modifica */etc/resolv.conf* per includere una riga in cima con il tuo host di analisi del traffico (ad esempio aggiungi "nameserver 127.0.0.1" se stai eseguendo in locale). In alternativa, puoi aggiungere un indirizzo di server DNS usando strumenti come Network Manager. Dentro Network Manager apri *Impostazioni IPv4*, seleziona *Solo indirizzi automatici (DHCP)* oppure *Manuale* dal menu a discesa *Metodo* e modifica la casella di testo *Server DNS* per includere un indirizzo IP con DNSChef in esecuzione.

- **Windows** - Seleziona *Connessioni di rete* dal *Pannello di controllo*. Quindi seleziona una delle connessioni (ad es. "Connessione alla rete locale"), fai clic con il tasto destro su di essa e scegli Proprietà. Nella finestra di dialogo appena apparsa, seleziona *Protocollo Internet (TCP/IP)* e fai clic su Proprietà. Infine seleziona il pulsante di opzione *Usa i seguenti indirizzi server DNS* e inserisci l'indirizzo IP con DNSChef in esecuzione. Per esempio, se stai eseguendo in locale inserisci 127.0.0.1.

- **OS X** - Apri *Preferenze di Sistema* e fai clic sull'icona *Rete*. Seleziona l'interfaccia attiva e compila il campo *Server DNS*. Se stai usando Airport, dovrai fare clic sul pulsante *Avanzate...* e modificare i server DNS da lì. In alternativa, puoi modificare */etc/resolv.conf* e aggiungere un nameserver fittizio in cima (ad es. "nameserver 127.0.0.1").

- **iOS** - Apri *Impostazioni* e seleziona *Generali*. Quindi seleziona *Wi-Fi* e fai clic sulla freccia blu a destra di un punto di accesso attivo dall'elenco. Modifica la voce DNS in modo che punti all'host con DNSChef in esecuzione. Assicurati di aver disattivato l'interfaccia Cellular (se disponibile).

- **Android** - Apri *Impostazioni* e seleziona *Wireless e reti*. Fai clic su *Impostazioni Wi-Fi* e seleziona *Avanzate* dopo aver premuto il pulsante *Opzioni* sul telefono. Abilita la casella di controllo *Usa IP statico* e configura un server DNS personalizzato.

Se non hai la possibilità di modificare manualmente le impostazioni DNS del dispositivo, hai comunque diverse opzioni che coinvolgono tecniche come [ARP Spoofing](http://en.wikipedia.org/wiki/ARP_spoofing), [Rogue DHCP](http://www.yersinia.net/doc.htm) e altri metodi creativi.

Infine, devi configurare un servizio fittizio a cui DNSChef farà puntare tutte le richieste. Per esempio, se stai cercando di intercettare il traffico web, devi avviare un server web separato in ascolto sulla porta 80 oppure impostare un proxy web (ad es. Burp) per intercettare il traffico. DNSChef farà puntare le query al tuo host proxy/server con servizi configurati correttamente.

## Eseguire DNSChef

DNSChef è un'applicazione cross-platform sviluppata in Python che dovrebbe funzionare sulla maggior parte delle piattaforme dotate di un interprete Python. Questa guida si concentrerà sugli ambienti Unix; tuttavia, tutti gli esempi seguenti sono stati testati e funzionano anche su Windows.

Proviamo DNSChef con la sua funzionalità di monitoraggio più basilare. Esegui il seguente comando come root (necessario per avviare un server sulla 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

Senza alcun parametro, DNSChef viene eseguito in modalità proxy completo. Ciò significa che tutte le richieste verranno semplicemente inoltrate a un server DNS upstream (8.8.8.8 di default) e restituite all'host che ha effettuato la query. Per esempio, interroghiamo un record "A" per un dominio e osserviamo i risultati:

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

DNSChef stamperà la seguente riga di log che mostra l'ora, l'indirizzo IP di origine, il tipo di record richiesto e, cosa più importante, quale nome è stato interrogato:

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

Questa modalità è utile per il semplice monitoraggio delle applicazioni quando devi capire quali domini usa per le sue comunicazioni.

DNSChef ha il pieno supporto per IPv6, che può essere attivato usando i flag *-6* o *--ipv6**. Funziona esattamente come la modalità IPv4, con l'eccezione che l'interfaccia di ascolto predefinita passa a ::1 e il server DNS predefinito passa a 2001:4860:4860::8888. Ecco un esempio di output:

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

    [*] Using IPv6 mode.
    [*] DNSChef started on interface: ::1
    [*] Using the following nameservers: 2001:4860:4860::8888
    [*] No parameters were specified. Running in full proxy mode
    [00:35:44] ::1: proxying the response of type 'A' for thesprawl.org
    [00:35:44] ::1: proxying the response of type 'AAAA' for thesprawl.org
    [00:35:44] ::1: proxying the response of type 'MX' for thesprawl.org

NOTA: di default, DNSChef crea un listener UDP. Puoi usare TCP invece con l'argomento *--tcp* discusso più avanti.

## Eseguire l'API HTTP di DNSChef

> [!WARNING]
> L'API non ha autenticazione. Consenti/nega l'accesso a livello di rete tramite security group, iptables, firewall, ecc.

`uvicorn dnschef.api:app`

Puoi quindi visualizzare la documentazione OpenAPI all'indirizzo `http://127.0.0.1:8000/docs````
$ uvicorn dnschef.api:app
INFO:     Started server process [28327]
INFO:     Waiting for application startup.
          _                _          __  
         | | version 0.6.0  | |        / _| 
       __| |_ __  ___  ___| |__   ___| |_ 
      / _` | '_ \/ __|/ __| '_ \ / _ \  _|
     | (_| | | | \__ \ (__| | | |  __/ |  
      \__,_|_| |_|___/\___|_| |_|\___|_|  
                @iphelix // @byt3bl33d3r  

2023-09-28 11:24:59 cooking replies                domain=*.thesprawl.org record=192.0.2.1 section=A
2023-09-28 11:24:59 cooking replies                domain=*.thesprawl.org record=2001:db8::1 section=AAAA
-- SNIP --
2023-09-28 11:24:59 cooking replies                domain=*.thesprawl.org record=1 . alpn=h2 ipv4hint=127.0.0.1 ipv6hint=::1 section=HTTPS
INFO:     Application startup complete.
2023-09-28 11:24:59 DNSChef is active              interface=127.0.0.1 ipv6=False nameservers=['8.8.8.8'] port=53 tcp=False
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)

# ./dnschef.py --fakeip 127.0.0.1 -q
[*] DNSChef started on interface: 127.0.0.1 
[*] Using the following nameservers: 8.8.8.8
[*] Cooking all A replies to point to 127.0.0.1
[23:55:57] 127.0.0.1: cooking the response of type 'A' for google.com to 127.0.0.1
[23:55:57] 127.0.0.1: proxying the response of type 'AAAA' for google.com
[23:55:57] 127.0.0.1: proxying the response of type 'MX' for google.com

$ host google.com localhost
google.com has address 127.0.0.1
google.com has IPv6 address 2001:4860:4001:803::1001
google.com mail is handled by 10 aspmx.l.google.com.
google.com mail is handled by 40 alt3.aspmx.l.google.com.
google.com mail is handled by 30 alt2.aspmx.l.google.com.
google.com mail is handled by 20 alt1.aspmx.l.google.com.
google.com mail is handled by 50 alt4.aspmx.l.google.com.

# ./dnschef.py --fakeip 127.0.0.1 --fakeipv6 ::1 -q
[*] DNSChef started on interface: 127.0.0.1 
[*] Using the following nameservers: 8.8.8.8
[*] Cooking all A replies to point to 127.0.0.1
[*] Cooking all AAAA replies to point to ::1
[00:02:14] 127.0.0.1: cooking the response of type 'A' for google.com to 127.0.0.1
[00:02:14] 127.0.0.1: cooking the response of type 'AAAA' for google.com to ::1
[00:02:14] 127.0.0.1: proxying the response of type 'MX' for google.com

$ host google.com localhost
google.com has address 127.0.0.1
google.com has IPv6 address ::1
google.com mail is handled by 10 aspmx.l.google.com.
google.com mail is handled by 40 alt3.aspmx.l.google.com.
google.com mail is handled by 30 alt2.aspmx.l.google.com.
google.com mail is handled by 20 alt1.aspmx.l.google.com.
google.com mail is handled by 50 alt4.aspmx.l.google.com.

# ./dnschef.py --fakeip 127.0.0.1 --fakeipv6 ::1 --fakemail mail.fake.com --fakealias www.fake.com --fakens ns.fake.com -q
[*] DNSChef started on interface: 127.0.0.1 
[*] Using the following nameservers: 8.8.8.8
[*] Cooking all A replies to point to 127.0.0.1
[*] Cooking all AAAA replies to point to ::1
[*] Cooking all MX replies to point to mail.fake.com
[*] Cooking all CNAME replies to point to www.fake.com
[*] Cooking all NS replies to point to ns.fake.com
[00:17:29] 127.0.0.1: cooking the response of type 'ANY' for google.com with all known fake records.

# host -t ANY google.com localhost
google.com has address 127.0.0.1
google.com has IPv6 address ::1
google.com mail is handled by 10 mail.fake.com.
google.com is an alias for www.fake.com.
google.com name server ns.fake.com.

# ./dnschef.py --fakeip 127.0.0.1 --fakedomains thesprawl.org -q
[*] DNSChef started on interface: 127.0.0.1
[*] Using the following nameservers: 8.8.8.8  
[*] Cooking replies to point to 127.0.0.1 matching: thesprawl.org
[00:23:37] 127.0.0.1: cooking the response of type 'A' for thesprawl.org to 127.0.0.1
[00:23:52] 127.0.0.1: proxying the response of type 'A' for mx9.webfaction.com

# ./dnschef.py --fakeip 127.0.0.1 --truedomains thesprawl.org,*.webfaction.com -q
[*] DNSChef started on interface: 127.0.0.1
[*] Using the following nameservers: 8.8.8.8  
[*] Cooking replies to point to 127.0.0.1 not matching: *.webfaction.com, thesprawl.org
[00:27:57] 127.0.0.1: proxying the response of type 'A' for mx9.webfaction.com
[00:28:05] 127.0.0.1: cooking the response of type 'A' for google.com to 127.0.0.1

Notate l'intestazione di sezione `[A]`: definisce il tipo di record per DNSChef. Ora osserviamo attentamente l'output di più query:

    # ./dnschef.py --file dnschef.toml -q
    [*] DNSChef started on interface: 127.0.0.1 
    [*] Using the following nameservers: 8.8.8.8
    [+] Cooking A replies for domain *.google.com with '192.0.2.1'
    [+] Cooking A replies for domain thesprawl.org with '192.0.2.2'
    [+] Cooking A replies for domain *.wordpress.* with '192.0.2.3'
    [00:43:54] 127.0.0.1: cooking the response of type 'A' for google.com to 192.0.2.1
    [00:44:05] 127.0.0.1: cooking the response of type 'A' for www.google.com to 192.0.2.1
    [00:44:19] 127.0.0.1: cooking the response of type 'A' for thesprawl.org to 192.0.2.2
    [00:44:29] 127.0.0.1: proxying the response of type 'A' for www.thesprawl.org
    [00:44:40] 127.0.0.1: cooking the response of type 'A' for www.wordpress.org to 192.0.2.3
    [00:44:51] 127.0.0.1: cooking the response of type 'A' for wordpress.com to 192.0.2.3
    [00:45:02] 127.0.0.1: proxying the response of type 'A' for slashdot.org

Sia *google.com* che *www.google.com* hanno corrisposto alla voce *\*.google.com* e sono stati risolti correttamente a *192.0.2.1*. D'altra parte, la richiesta per *www.thesprawl.org* è stata semplicemente inoltrata tramite proxy invece di essere modificata. Infine, tutte le varianti di *wordpress.com*, *www.wordpress.org*, ecc. hanno corrisposto alla maschera *\*.wordpress.\** e sono state risolte correttamente a *192.0.2.3*. Da ultimo, una query non definita per *slashdot.org* è stata semplicemente inoltrata tramite proxy con una risposta reale.

È possibile specificare intestazioni di sezione per tutti gli altri tipi di record DNS supportati, inclusi quelli non esplicitamente esposti sulla riga di comando: [A], [AAAA], [MX], [NS], [CNAME], [PTR], [NAPTR] e [SOA]. Ad esempio, definiamo una nuova sezione [PTR] nel file `dnschef.toml`:```toml
[PTR]
"*.2.0.192.in-addr.arpa"="fake.com"

 ./dnschef.py --file dnschef.toml -q
[sudo] password for iphelix: 
[*] DNSChef started on interface: 127.0.0.1 
[*] Using the following nameservers: 8.8.8.8
[+] Cooking PTR replies for domain *.2.0.192.in-addr.arpa with 'fake.com'
[00:11:34] 127.0.0.1: cooking the response of type 'PTR' for 1.2.0.192.in-addr.arpa to fake.com

$ host 192.0.2.1 localhost
1.2.0.192.in-addr.arpa domain name pointer fake.com.

Vedi il file di esempio `dnschef.toml` per ulteriori esempi.

## Staging dei File

DNSChef può "mettere in staging" qualsiasi file tramite DNS. Attualmente lo staging dei file è supportato solo con i record `A`, `AAAA` e `TXT` (ne verranno aggiunti altri). Per istruire DNSChef a mettere in staging un file, aggiungi la seguente sezione al tuo `dnschef.toml`:```toml
[A]
"*.wat.org" = { file = "/home/payload.exe", chunk_size = 4 }

[AAAA]
"*.gorgetowngeronimos.org" = { file = "/home/payload.exe", chunk_size = 16 }

Con questa configurazione, qualsiasi query `TXT` a `ns*.dungbeetle.org` restituirà un chunk del nostro file situato localmente sul filesystem in `~/payload.exe`.

Le impostazioni `response_format` e `response_prefix_pool` sono opzionali ma consentono di personalizzare ulteriormente la risposta DNS `TXT`.

L'impostazione `response_format` definisce il formato della risposta `TXT`:

- La variabile `{prefix}` verrà sostituita casualmente con uno dei valori definiti nell'array `response_prefix_pool`.

- La variabile `{chunk}` verrà sostituita con il chunk del file.

Con la configurazione precedente, una query `TXT` a `ns1.dungbeetle.org` restituirà la seguente risposta:```
docusign=test-<BASE64_ENCODED_FILE_CHUNK_N1>

## Filtri avanzati

È possibile combinare input da un file e dalla riga di comando. Ad esempio, il seguente comando utilizza entrambi i parametri `--file` e `--fakedomains`:

    # ./dnschef.py --file dnschef.toml --fakeip 6.6.6.6 --fakedomains=thesprawl.org,slashdot.org -q
    [*] DNSChef started on interface: 127.0.0.1 
    [*] Using the following nameservers: 8.8.8.8
    [+] Cooking A replies for domain *.google.com with '192.0.2.1'
    [+] Cooking A replies for domain thesprawl.org with '192.0.2.2'
    [+] Cooking A replies for domain *.wordpress.* with '192.0.2.3'
    [*] Cooking A replies to point to 6.6.6.6 matching: *.wordpress.*, *.google.com, thesprawl.org
    [*] Cooking A replies to point to 6.6.6.6 matching: slashdot.org, *.wordpress.*, *.google.com, thesprawl.org
    [00:49:05] 127.0.0.1: cooking the response of type 'A' for google.com to 192.0.2.1
    [00:49:15] 127.0.0.1: cooking the response of type 'A' for slashdot.org to 6.6.6.6
    [00:49:31] 127.0.0.1: cooking the response of type 'A' for thesprawl.org to 6.6.6.6
    [00:50:08] 127.0.0.1: proxying the response of type 'A' for tor.com

Nota che la definizione di *thesprawl.org* nel parametro della riga di comando ha avuto precedenza su *dnschef.toml*. Questo può essere utile se si desidera sovrascrivere i valori nel file di configurazione. slashdot.org viene ancora risolto nell'indirizzo IP fittizio perché è stato specificato nel parametro *--fakedomains*. La richiesta per tor.com viene semplicemente inoltrata tramite proxy poiché non è stata specificata né nella riga di comando né nel file di configurazione.

## Altre configurazioni

Per motivi di sicurezza, DNSChef ascolta di default su un'interfaccia locale 127.0.0.1 (o ::1 per IPv6). È possibile fare in modo che DNSChef ascolti su un'altra interfaccia usando il parametro *--interface*:

    # ./dnschef.py --interface 0.0.0.0 -q
    [*] DNSChef started on interface: 0.0.0.0
    [*] Using the following nameservers: 8.8.8.8 
    [*] No parameters were specified. Running in full proxy mode
    [00:50:53] 192.0.2.105: proxying the response of type 'A' for thesprawl.org

oppure per IPv6:

    # ./dnschef.py -6 --interface :: -q
    [*] Using IPv6 mode.
    [*] DNSChef started on interface: ::
    [*] Using the following nameservers: 2001:4860:4860::8888
    [*] No parameters were specified. Running in full proxy mode
    [00:57:46] 2001:db8::105: proxying the response of type 'A' for thesprawl.org

Di default, DNSChef utilizza il server DNS pubblico di Google per effettuare le richieste proxy. Tuttavia, è possibile definire un elenco personalizzato di nameserver usando il parametro *--nameservers*:

    # ./dnschef.py --nameservers 4.2.2.1,4.2.2.2 -q
    [*] DNSChef started on interface: 127.0.0.1 
    [*] Using the following nameservers: 4.2.2.1, 4.2.2.2
    [*] No parameters were specified. Running in full proxy mode
    [00:55:08] 127.0.0.1: proxying the response of type 'A' for thesprawl.org

È possibile specificare una porta nameserver non standard usando la notazione IP#PORT:

    # ./dnschef.py --nameservers 192.0.2.2#5353 -q
    [*] DNSChef started on interface: 127.0.0.1 
    [*] Using the following nameservers: 192.0.2.2#5353
    [*] No parameters were specified. Running in full proxy mode
    [02:03:12] 127.0.0.1: proxying the response of type 'A' for thesprawl.org

Allo stesso tempo è possibile avviare DNSChef stesso su una porta alternativa usando il parametro `-p port#`:

    # ./dnschef.py -p 5353 -q
    [*] Listening on an alternative port 5353
    [*] 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

Il protocollo DNS può essere utilizzato tramite UDP (predefinito) o TCP. DNSChef implementa una modalità TCP che può essere attivata con il flag `--tcp`.