dnschef-ng

DNSChef पैनेट्रेशन टेस्टर्स और मैलवेयर विश्लेषकों के लिए एक अत्यधिक कॉन्फ़िगर करने योग्य DNS प्रॉक्सी है। DNS प्रॉक्सी (उर्फ "फर्जी DNS") एक उपकरण है जिसका उपयोग अन्य उपयोगों के अलावा एप्लिकेशन नेटवर्क ट्रैफ़िक विश्लेषण के लिए किया जाता है। उदाहरण के लिए, DNS प्रॉक्सी का उपयोग "badguy.com" के अनुरोधों को नकली बनाने के लिए किया जा सकता है, ताकि वे इंटरनेट पर कहीं वास्तविक होस्ट के बजाय स्थानीय मशीन पर समाप्ति या अवरोधन के लिए इंगित हों। 

वहाँ कई DNS प्रॉक्सी मौजूद हैं। अधिकांश बस सभी DNS क्वेरी को एकल IP पते पर इंगित कर देते हैं या केवल बुनियादी फ़िल्टरिंग लागू करते हैं। DNSChef एक पैनेट्रेशन परीक्षण के भाग के रूप में विकसित किया गया था जहाँ अधिक कॉन्फ़िगर करने योग्य प्रणाली की आवश्यकता थी। परिणामस्वरूप, DNSChef एक क्रॉस-प्लेटफ़ॉर्म एप्लिकेशन है जो समावेशी और अनन्य डोमेन सूचियों के आधार पर प्रतिक्रियाओं को गढ़ने, कई DNS रिकॉर्ड प्रकारों का समर्थन करने, वाइल्डकार्ड के साथ डोमेन मिलान करने, गैर-मिलान वाले डोमेन के लिए वास्तविक प्रतिक्रियाओं को प्रॉक्सी करने, बाहरी कॉन्फ़िगरेशन फ़ाइलों को परिभाषित करने, IPv6 और कई अन्य सुविधाओं में सक्षम है। प्रत्येक सुविधा और सुझाए गए उपयोगों का विस्तृत विवरण नीचे पाया जा सकता है।

DNS प्रॉक्सी के उपयोग की अनुशंसा उन स्थितियों में की जाती है जहाँ किसी एप्लिकेशन को सीधे किसी अन्य प्रॉक्सी सर्वर का उपयोग करने के लिए बाध्य करना संभव नहीं होता है। उदाहरण के लिए, कुछ मोबाइल एप्लिकेशन OS HTTP प्रॉक्सी सेटिंग्स को पूरी तरह से अनदेखा कर देते हैं। ऐसे मामलों में, DNSChef जैसे DNS प्रॉक्सी सर्वर का उपयोग आपको उस एप्लिकेशन को वांछित गंतव्य पर कनेक्शन अग्रेषित करने के लिए धोखा देने की अनुमति देगा।

## नई सुविधाएँ 

- Python 3.11+ आवश्यक है
- DNS के माध्यम से स्टेजिंग फ़ाइलों का समर्थन करता है (अभी केवल `A`,`AAAA`,`TXT` पर...)
- कॉन्फ़िग फ़ाइल अब TOML है
- वैकल्पिक HTTP API (आपको लॉग क्वेरी करने और कॉन्फ़िग को दूरस्थ रूप से अपडेट करने की अनुमति देता है)
- बेहतर प्रदर्शन के लिए पूर्ण रूप से async (AsyncIO का उपयोग करता है)
- संरचित लॉगिंग और कई QOL सुधार
- अब एक Python पैकेज है
- Dockerized
- मूल रिपॉजिटरी से कई PR और फिक्स शामिल हैं

## इंस्टॉल करना

नवीनतम रिलीज़ इंस्टॉल करने के लिए आपको [pipx](https://pypa.github.io/pipx/) का उपयोग करना चाहिए (जब तक कि आप कोई ऐसे बेकार व्यक्ति न हों जो ढीली-ढाली शर्तों का आनंद लेता है):

    pipx install dnschef-ng

यदि आप HTTP API चाहते हैं (कुछ अतिरिक्त निर्भरताओं की आवश्यकता होती है):
    
    pipx install dnschef-ng[api]

Git से pipx का उपयोग करके नवीनतम संस्करण इंस्टॉल करें:

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

HTTP API के लिए निर्भरताओं के साथ Git से pipx का उपयोग करके नवीनतम संस्करण इंस्टॉल करें:

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


## DNS प्रॉक्सी सेट करना

DNSChef का उपयोग शुरू करने से पहले, आपको अपनी मशीन को एक DNS नेमसर्वर का उपयोग करने के लिए कॉन्फ़िगर करना होगा जिस पर टूल चल रहा हो। आपके द्वारा उपयोग किए जाने वाले ऑपरेटिंग सिस्टम के आधार पर आपके पास कई विकल्प हैं:

- **Linux** - अपने ट्रैफ़िक विश्लेषण होस्ट के साथ सबसे ऊपर एक पंक्ति शामिल करने के लिए */etc/resolv.conf* को संपादित करें (जैसे यदि आप स्थानीय रूप से चला रहे हैं तो "nameserver 127.0.0.1"  जोड़ें)। वैकल्पिक रूप से, आप Network Manager जैसे टूल का उपयोग करके DNS सर्वर पता जोड़ सकते हैं। Network Manager के अंदर IPv4 सेटिंग्स खोलें, *Method* ड्रॉप डाउन बॉक्स से *Automatic (DHCP) addresses only* या *Manual* चुनें और DNSChef चल रहे IP पते को शामिल करने के लिए *DNS Servers* टेक्स्ट बॉक्स को संपादित करें।

- **Windows** - *Control Panel* से *Network Connections* चुनें। इसके बाद किसी एक कनेक्शन (जैसे "Local Area Connection") को चुनें, उस पर राइट-क्लिक करें और Properties चुनें। नए दिखाई देने वाले डायलॉग बॉक्स के भीतर, *Internet Protocol (TCP/IP)* चुनें और properties पर क्लिक करें। अंत में *Use the following DNS server addresses* रेडियो बटन चुनें और DNSChef चल रहे IP पते को दर्ज करें। उदाहरण के लिए, यदि स्थानीय रूप से चल रहा है तो 127.0.0.1 दर्ज करें।

- **OS X** - *System Preferences* खोलें और *Network* आइकन पर क्लिक करें। सक्रिय इंटरफ़ेस चुनें और *DNS Server* फ़ील्ड भरें। यदि आप Airport का उपयोग कर रहे हैं तो आपको *Advanced...* बटन पर क्लिक करना होगा और वहां से DNS सर्वर संपादित करना होगा। वैकल्पिक रूप से, आप */etc/resolv.conf* को संपादित कर सकते हैं और वहाँ बिल्कुल ऊपर एक फर्जी नेमसर्वर जोड़ सकते हैं (जैसे "nameserver 127.0.0.1")।

- **iOS** - *Settings* खोलें और *General* चुनें। इसके बाद *Wi-Fi* चुनें और सूची में एक सक्रिय Access Point के दाईं ओर नीले तीर पर क्लिक करें। DNS प्रविष्टि को DNSChef चल रहे होस्ट की ओर इंगित करने के लिए संपादित करें। सुनिश्चित करें कि आपने Cellular इंटरफ़ेस (यदि उपलब्ध हो) अक्षम कर दिया है।

- **Android** - *Settings* खोलें और *Wireless and network* चुनें। फ़ोन पर *Options* बटन दबाने के बाद *Wi-Fi settings* पर क्लिक करें और *Advanced* चुनें। *Use static IP* चेकबॉक्स सक्षम करें और एक कस्टम DNS सर्वर कॉन्फ़िगर करें।

यदि आपके पास डिवाइस की DNS सेटिंग्स को मैन्युअल रूप से संशोधित करने की क्षमता नहीं है, तो आपके पास अभी भी कई विकल्प हैं जिनमें [ARP Spoofing](http://en.wikipedia.org/wiki/ARP_spoofing), [Rogue DHCP](http://www.yersinia.net/doc.htm) और अन्य रचनात्मक तरीके जैसी तकनीकें शामिल हैं।

अंत में आपको एक फर्जी सेवा कॉन्फ़िगर करने की आवश्यकता है जहाँ DNSChef सभी अनुरोधों को इंगित करेगा। उदाहरण के लिए, यदि आप वेब ट्रैफ़िक को इंटरसेप्ट करने का प्रयास कर रहे हैं, तो आपको पोर्ट 80 पर चलने वाला एक अलग वेब सर्वर शुरू करना होगा या ट्रैफ़िक इंटरसेप्ट करने के लिए एक वेब प्रॉक्सी (जैसे Burp) सेट करनी होगी। DNSChef क्वेरी को आपके प्रॉक्सी/सर्वर होस्ट पर उचित रूप से कॉन्फ़िगर की गई सेवाओं के साथ इंगित करेगा।

## DNSChef चलाना

DNSChef Python में विकसित एक क्रॉस-प्लेटफ़ॉर्म एप्लिकेशन है जो अधिकांश प्लेटफ़ॉर्म पर चलना चाहिए जिनमें Python इंटरप्रेटर होता है। यह मार्गदर्शिका Unix वातावरण पर केंद्रित होगी; हालाँकि, नीचे दिए गए सभी उदाहरण Windows पर भी काम करने के लिए परीक्षण किए गए थे।

आइए DNSChef की सबसे बुनियादी निगरानी कार्यक्षमता को आज़माएँ। रूट के रूप में निम्न कमांड निष्पादित करें (पोर्ट 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

बिना किसी पैरामीटर के, DNSChef पूर्ण प्रॉक्सी मोड में चलेगा। इसका मतलब है कि सभी अनुरोध केवल एक अपस्ट्रीम DNS सर्वर (डिफ़ॉल्ट रूप से 8.8.8.8) को अग्रेषित किए जाएंगे और क्वेरी करने वाले होस्ट को वापस कर दिए जाएंगे। उदाहरण के लिए, आइए एक डोमेन के लिए "A" रिकॉर्ड क्वेरी करें और परिणाम देखें:

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

DNSChef निम्नलिखित लॉग लाइन प्रिंट करेगा जिसमें समय, स्रोत IP पता, अनुरोधित रिकॉर्ड का प्रकार और सबसे महत्वपूर्ण रूप से कौन सा नाम क्वेरी किया गया था, दिखाई देगा:

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

यह मोड सरल एप्लिकेशन मॉनिटरिंग के लिए उपयोगी है जहाँ आपको यह पता लगाने की आवश्यकता होती है कि यह अपने संचार के लिए किन डोमेन का उपयोग करता है।

DNSChef में IPv6 के लिए पूर्ण समर्थन है जिसे *-6* या *--ipv6** फ़्लैग का उपयोग करके सक्रिय किया जा सकता है। यह बिल्कुल IPv4 मोड की तरह काम करता है, सिवाय इसके कि डिफ़ॉल्ट सुनने वाला इंटरफ़ेस ::1 पर स्विच हो जाता है और डिफ़ॉल्ट DNS सर्वर 2001:4860:4860::8888 पर स्विच हो जाता है। यहाँ एक नमूना आउटपुट है:

    # ./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

नोट: डिफ़ॉल्ट रूप से, DNSChef एक UDP लिसनर बनाता है। आप इसके बजाय *--tcp* तर्क का उपयोग करके TCP का उपयोग कर सकते हैं, जिस पर बाद में चर्चा की गई है।

## DNSChef HTTP API चलाना

> [!WARNING]
> API में कोई प्रमाणीकरण नहीं है। सुरक्षा समूहों, iptables, फ़ायरवॉल आदि के माध्यम से नेटवर्क स्तर पर पहुँच की अनुमति/अस्वीकृति दें।

`uvicorn dnschef.api:app`

फिर आप `http://127.0.0.1:8000/docs` पर OpenAPI दस्तावेज़ देख सकते हैं।```
$ 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

`[A]` सेक्शन हेडर पर ध्यान दें, यह DNSChef को रिकॉर्ड प्रकार परिभाषित करता है। अब आइए ध्यान से कई क्वेरीज़ के आउटपुट का अवलोकन करें:

    # ./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

दोनों *google.com* और *www.google.com* ने *\*.google.com* एंट्री से मेल खाया और सही ढंग से *192.0.2.1* पर रिज़ॉल्व हुए। दूसरी ओर *www.thesprawl.org* अनुरोध को संशोधित किए बिना केवल प्रॉक्सी कर दिया गया। अंत में *wordpress.com*, *www.wordpress.org*, आदि के सभी रूपांतरों ने *\*.wordpress.\** मास्क से मेल खाया और सही ढंग से *192.0.2.3* पर रिज़ॉल्व हुए। अंत में एक अपरिभाषित *slashdot.org* क्वेरी को वास्तविक प्रतिक्रिया के साथ केवल प्रॉक्सी कर दिया गया।

आप कमांड लाइन पर स्पष्ट रूप से प्रदर्शित न किए गए सहित अन्य सभी समर्थित DNS रिकॉर्ड प्रकारों के लिए सेक्शन हेडर निर्दिष्ट कर सकते हैं: [A], [AAAA], [MX], [NS], [CNAME], [PTR], [NAPTR] और [SOA]। उदाहरण के लिए, `dnschef.toml` फ़ाइल में एक नया [PTR] सेक्शन परिभाषित करें:```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.

अतिरिक्त उदाहरणों के लिए नमूना `dnschef.toml` फ़ाइल देखें।

## फ़ाइल स्टेजिंग

DNSChef DNS के माध्यम से किसी भी फ़ाइल को "स्टेज" कर सकता है। वर्तमान में फ़ाइल स्टेजिंग केवल `A`, `AAAA` और `TXT` रिकॉर्ड के साथ समर्थित है (और अधिक जोड़े जाएँगे)। DNSChef को किसी फ़ाइल को स्टेज करने का निर्देश देने के लिए, अपनी `dnschef.toml` में निम्नलिखित अनुभाग जोड़ें:```toml
[A]
"*.wat.org" = { file = "/home/payload.exe", chunk_size = 4 }

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

इस कॉन्फ़िगरेशन के साथ, `ns*.dungbeetle.org` पर कोई भी `TXT` क्वेरी हमारी फ़ाइल का एक हिस्सा लौटाएगी जो फ़ाइल सिस्टम पर स्थानीय रूप से `~/payload.exe` पर स्थित है।

`response_format` और `response_prefix_pool` सेटिंग्स वैकल्पिक हैं, लेकिन आपको DNS `TXT` प्रतिक्रिया को और अधिक अनुकूलित करने की अनुमति देती हैं।

`response_format` सेटिंग `TXT` प्रतिक्रिया का प्रारूप परिभाषित करती है:

- `{prefix}` वेरिएबल को `response_prefix_pool` ऐरे में परिभाषित मानों में से एक के साथ यादृच्छिक रूप से प्रतिस्थापित किया जाएगा।

- `{chunk}` वेरिएबल को फ़ाइल हिस्से के साथ बदल दिया जाएगा।

उपरोक्त कॉन्फ़िगरेशन के साथ, `ns1.dungbeetle.org` पर एक `TXT` क्वेरी निम्नलिखित प्रतिक्रिया लौटाएगी:```
docusign=test-<BASE64_ENCODED_FILE_CHUNK_N1>

## उन्नत फ़िल्टरिंग

आप फ़ाइल और कमांड लाइन से इनपुट मिलाकर उपयोग कर सकते हैं। उदाहरण के लिए निम्न कमांड `--file` और `--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

ध्यान दें कि कमांड लाइन पैरामीटर में *thesprawl.org* की परिभाषा ने *dnschef.toml* की तुलना में प्राथमिकता ली। यह उपयोगी हो सकता है यदि आप कॉन्फ़िगरेशन फ़ाइल में मानों को ओवरराइड करना चाहते हैं। slashdot.org अभी भी नकली IP पते पर रिज़ॉल्व होता है क्योंकि यह *--fakedomains* पैरामीटर में निर्दिष्ट किया गया था। tor.com अनुरोध को केवल प्रॉक्सी किया जाता है क्योंकि यह न तो कमांड लाइन में और न ही कॉन्फ़िगरेशन फ़ाइल में निर्दिष्ट था।

## अन्य कॉन्फ़िगरेशन

सुरक्षा कारणों से, DNSChef डिफ़ॉल्ट रूप से स्थानीय 127.0.0.1 (या IPv6 के लिए ::1) इंटरफ़ेस पर सुनता है। आप *--interface* पैरामीटर का उपयोग करके DNSChef को किसी अन्य इंटरफ़ेस पर सुनने के लिए बना सकते हैं:

    # ./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

या 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

डिफ़ॉल्ट रूप से, DNSChef प्रॉक्सी अनुरोध करने के लिए Google के सार्वजनिक DNS सर्वर का उपयोग करता है। हालाँकि, आप *--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

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

साथ ही, `-p port#` पैरामीटर का उपयोग करके DNSChef को स्वयं एक वैकल्पिक पोर्ट पर शुरू करना संभव है:

    # ./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

DNS प्रोटोकॉल का उपयोग UDP (डिफ़ॉल्ट) या TCP पर किया जा सकता है। DNSChef एक TCP मोड लागू करता है जिसे `--tcp` फ़्लैग के साथ सक्रिय किया जा सकता है।