MASSCAN: बड़े पैमाने पर आईपी पोर्ट स्कैनर

यह एक इंटरनेट-स्तरीय पोर्ट स्कैनर है। यह एक ही मशीन से 10 मिलियन पैकेट प्रति सेकंड संचारित करते हुए पूरे इंटरनेट को 5 मिनट से भी कम समय में स्कैन कर सकता है।

इसका उपयोग (पैरामीटर, आउटपुट) सबसे प्रसिद्ध पोर्ट स्कैनर nmap के समान है। संदेह होने पर, उन सुविधाओं में से एक को आज़माएं -- ऐसी सुविधाएं जो कई मशीनों के व्यापक स्कैनिंग का समर्थन करती हैं, समर्थित हैं, जबकि एकल मशीनों की गहन स्कैनिंग नहीं की जाती है।

आंतरिक रूप से, यह scanrand, unicornscan, और ZMap जैसे पोर्ट स्कैनर के समान अतुल्यकालिक संचरण का उपयोग करता है। यह अधिक लचीला है, जो मनमानी पोर्ट और पते की श्रेणियों की अनुमति देता है।

नोट: masscan अपने स्वयं के तदर्थ TCP/IP स्टैक का उपयोग करता है। साधारण पोर्ट स्कैन के अलावा कुछ भी स्थानीय TCP/IP स्टैक के साथ विरोध का कारण बन सकता है। इसका मतलब है कि आपको या तो किसी भिन्न IP पते से चलाने के लिए --src-ip विकल्प का उपयोग करना होगा, या --src-port का उपयोग करके यह कॉन्फ़िगर करना होगा कि masscan किन स्रोत पोर्ट का उपयोग करता है, फिर आंतरिक फ़ायरवॉल (जैसे pf या iptables) को भी कॉन्फ़िगर करना होगा ताकि उन पोर्ट को शेष ऑपरेटिंग सिस्टम से फ़ायरवॉल किया जा सके।

यह उपकरण मुफ्त है, लेकिन इसके विकास में धन का योगदान करने पर विचार करें: Bitcoin वॉलेट पता: 1MASSCANaHUiyTtR3bJ2sLGuMw5kDBaj4T

निर्माण

Debian/Ubuntu पर, यह कुछ इस प्रकार है। सी कंपाइलर (जैसे gcc या clang) के अलावा इसकी कोई वास्तविक निर्भरता नहीं है।

sudo apt-get --assume-yes install git make gcc
git clone https://github.com/robertdavidgraham/masscan
cd masscan
make

यह प्रोग्राम को masscan/bin उपनिर्देशिका में रखता है। इसे (लिनक्स पर) स्थापित करने के लिए चलाएं:

make install

स्रोत में बहुत सारी छोटी फ़ाइलें होती हैं, इसलिए मल्टी-थ्रेडेड बिल्ड का उपयोग करके निर्माण बहुत तेज हो जाता है। इसके लिए Raspberry Pi पर 2 गीगाबाइट से अधिक की आवश्यकता होती है (और टूट जाता है), इसलिए आप सभी संभावित थ्रेड के बजाय एक छोटी संख्या, जैसे -j4 का उपयोग कर सकते हैं।

make -j

जबकि लिनक्स प्राथमिक लक्ष्य प्लेटफॉर्म है, कोड कई अन्य सिस्टम (विंडोज, मैकओएस, आदि) पर अच्छी तरह से चलता है। यहां कुछ अतिरिक्त बिल्ड जानकारी दी गई है:

• Windows w/ विजुअल स्टूडियो: VS10 प्रोजेक्ट का उपयोग करें
• Windows w/ MinGW: बस make टाइप करें
• Windows w/ cygwin: काम नहीं करेगा
• Mac OS X /w XCode: XCode4 प्रोजेक्ट का उपयोग करें
• Mac OS X /w cmdline: बस make टाइप करें
• FreeBSD: gmake टाइप करें
• अन्य: सभी फाइलों को एक साथ संकलित करने का प्रयास करें, cc src/*.c -o bin/masscan

macOS पर, x86 बाइनरी ARM एमुलेशन के तहत उतनी ही तेजी से काम करते प्रतीत होते हैं।

उपयोग

उपयोग nmap के समान है। कुछ पोर्ट के लिए नेटवर्क सेगमेंट को स्कैन करने के लिए:

# masscan -p80,8000-8100 10.0.0.0/8 2603:3001:2d00:da00::/112

यह करेगा:

• 10.x.x.x सबनेट, और 2603:3001:2d00:da00::x सबनेट को स्कैन करें
• दोनों सबनेट पर पोर्ट 80 और 8000 से 8100 की सीमा, या कुल 102 पोर्ट स्कैन करें
• आउटपुट को <stdout> पर प्रिंट करें जिसे एक फ़ाइल में रीडायरेक्ट किया जा सकता है

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

# masscan -p80,8000-8100 10.0.0.0/8 2603:3001:2d00:da00::/112 --echo > xxx.conf
# masscan -c xxx.conf --rate 1000

बैनर जाँच

मास्कैन केवल यह पता लगाने से अधिक कर सकता है कि पोर्ट खुले हैं या नहीं। यह सरल "बैनर" जानकारी प्राप्त करने के लिए TCP कनेक्शन और उस पोर्ट पर एप्लिकेशन के साथ इंटरैक्शन भी पूरा कर सकता है।

Masscan निम्नलिखित प्रोटोकॉल पर बैनर जाँच का समर्थन करता है:

• FTP
• HTTP
• IMAP4
• memcached
• POP3
• SMTP
• SSH
• SSL
• SMBv1
• SMBv2
• Telnet
• RDP
• VNC

इसके साथ समस्या यह है कि masscan में उस सिस्टम से अलग अपना स्वयं का TCP/IP स्टैक होता है जिस पर आप इसे चलाते हैं। जब स्थानीय सिस्टम को जांचे गए लक्ष्य से SYN-ACK प्राप्त होता है, तो यह RST पैकेट के साथ प्रतिक्रिया करता है जो masscan द्वारा बैनर प्राप्त करने से पहले कनेक्शन को समाप्त कर देता है।

इसे रोकने का सबसे आसान तरीका masscan को एक अलग IP पता निर्दिष्ट करना है। यह निम्नलिखित उदाहरणों में से एक जैसा दिखेगा:

# masscan 10.0.0.0/8 -p80 --banners --source-ip 192.168.1.200
  # masscan 2a00:1450:4007:810::/112 -p80 --banners --source-ip 2603:3001:2d00:da00:91d7:b54:b498:859d

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

कुछ मामलों में, जैसे वाई-फाई, यह संभव नहीं है। ऐसे मामलों में, आप masscan द्वारा उपयोग किए जाने वाले पोर्ट को फ़ायरवॉल कर सकते हैं। यह स्थानीय TCP/IP स्टैक को पैकेट देखने से रोकता है, लेकिन masscan इसे अभी भी देखता है क्योंकि यह स्थानीय स्टैक को बायपास करता है। लिनक्स के लिए, यह इस तरह दिखेगा:

# iptables -A INPUT -p tcp --dport 61000 -j DROP
# masscan 10.0.0.0/8 -p80 --banners --source-port 61000

आप शायद ऐसे पोर्ट चुनना चाहेंगे जो लिनक्स द्वारा स्रोत-पोर्ट के लिए चुने जा सकने वाले पोर्ट से टकरा न सकें। आप लिनक्स द्वारा उपयोग की जाने वाली सीमा को फ़ाइल में देखकर और उस सीमा को पुन: कॉन्फ़िगर कर सकते हैं:

/proc/sys/net/ipv4/ip_local_port_range

Kali Linux के नवीनतम संस्करण (अगस्त 2018) पर, वह सीमा 32768 से 60999 है, इसलिए आपको 32768 से नीचे या 61000 और उससे ऊपर के पोर्ट चुनने चाहिए।

iptables नियम सेट करना केवल अगले रीबूट तक रहता है। आपको अपने डिस्ट्रो के अनुसार कॉन्फ़िगरेशन को सहेजने का तरीका देखना होगा, जैसे iptables-save और/या iptables-persistent का उपयोग करना।

Mac OS X और BSD पर, समान चरण हैं। बचने के लिए रेंज का पता लगाने के लिए, निम्नलिखित जैसे कमांड का उपयोग करें:

# sysctl net.inet.ip.portrange.first net.inet.ip.portrange.last

FreeBSD और पुराने MacOS पर, ipfw कमांड का उपयोग करें:

# sudo ipfw add 1 deny tcp from any to any 40000 in
# masscan 10.0.0.0/8 -p80 --banners --source-port 40000

नए MacOS और OpenBSD पर, pf पैकेट-फ़िल्टर उपयोगिता का उपयोग करें। फ़ाइल /etc/pf.conf को संपादित करके निम्नलिखित जैसी एक पंक्ति जोड़ें:

block in proto tcp from any to any port 40000:40015

फिर फ़ायरवॉल को सक्षम करने के लिए, कमांड चलाएँ:

# pfctl -E    

यदि फ़ायरवॉल पहले से चल रहा है, तो या तो रीबूट करें या निम्नलिखित कमांड के साथ नियमों को पुनः लोड करें:

# pfctl -f /etc/pf.conf

Windows RST पैकेट के साथ प्रतिक्रिया नहीं करता है, इसलिए इनमें से कोई भी तकनीक आवश्यक नहीं है। हालांकि, masscan अभी भी अपने स्वयं के IP पते का उपयोग करके सबसे अच्छा काम करने के लिए डिज़ाइन किया गया है, इसलिए जब संभव हो तो आपको इस तरह से चलाना चाहिए, भले ही यह सख्ती से आवश्यक न हो।

अन्य जांचों के लिए भी यही आवश्यक है, जैसे --heartbleed जांच, जो बैनर जांच का एक रूप है।

पूरे इंटरनेट को कैसे स्कैन करें

जबकि छोटे, आंतरिक नेटवर्क के लिए उपयोगी, प्रोग्राम वास्तव में पूरे इंटरनेट को ध्यान में रखकर डिज़ाइन किया गया है। यह कुछ इस तरह दिख सकता है:

# masscan 0.0.0.0/0 -p0-65535

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

# masscan 0.0.0.0/0 -p0-65535 --excludefile exclude.txt

यह केवल परिणामों को कमांड-लाइन पर प्रिंट करता है। आप शायद उन्हें इसके बजाय एक फ़ाइल में सहेजना चाहते हैं। इसलिए, आप कुछ इस तरह चाहते हैं:

# masscan 0.0.0.0/0 -p0-65535 -oX scan.xml

यह परिणामों को एक XML फ़ाइल में सहेजता है, जिससे आप आसानी से परिणामों को डेटाबेस या किसी चीज़ में डंप कर सकते हैं।

लेकिन, यह केवल 100 पैकेट/सेकंड की डिफ़ॉल्ट दर पर जाता है, जो इंटरनेट को स्कैन करने में हमेशा लगेगा। आपको इसे इस प्रकार गति देनी होगी:

# masscan 0.0.0.0/0 -p0-65535 --max-rate 100000

यह दर को 100,000 पैकेट/सेकंड तक बढ़ा देता है, जो प्रति पोर्ट लगभग 10 घंटे में पूरे इंटरनेट (बहिष्कृत को छोड़कर) को स्कैन करेगा (या सभी पोर्ट स्कैन करने पर 655,360 घंटे)।

इस कमांड-लाइन के बारे में ध्यान देने वाली बात यह है कि ये सभी nmap संगत विकल्प हैं। इसके अलावा, nmap के अनुकूल "अदृश्य" विकल्प भी आपके लिए सेट किए गए हैं: -sS -Pn -n --randomize-hosts --send-eth। इसी प्रकार, XML फ़ाइल का प्रारूप nmap से प्रेरित है। बेशक, बहुत सारे अंतर हैं, क्योंकि प्रोग्राम की अतुल्यकालिक प्रकृति समस्या के लिए मौलिक रूप से भिन्न दृष्टिकोण की ओर ले जाती है।

उपरोक्त कमांड-लाइन थोड़ी बोझिल है। सब कुछ कमांड-लाइन पर रखने के बजाय, इसे एक फ़ाइल में संग्रहीत किया जा सकता है। उपरोक्त सेटिंग्स इस तरह दिखेंगी:

# My Scan
rate =  100000.00
output-format = xml
output-status = all
output-filename = scan.xml
ports = 0-65535
range = 0.0.0.0-255.255.255.255
excludefile = exclude.txt

इस कॉन्फ़िगरेशन फ़ाइल का उपयोग करने के लिए, -c का उपयोग करें:

# masscan -c myscan.conf

यह स्कैन को दोहराते समय भी चीजों को आसान बनाता है।

डिफ़ॉल्ट रूप से, masscan पहले कॉन्फ़िगरेशन फ़ाइल /etc/masscan/masscan.conf लोड करता है। कोई भी बाद का कॉन्फ़िगरेशन पैरामीटर इस डिफ़ॉल्ट कॉन्फ़िगरेशन फ़ाइल में मौजूद चीज़ों को ओवरराइड करता है। यहीं पर मैं अपना "excludefile" पैरामीटर रखता हूं ताकि मैं इसे कभी न भूलूं। यह स्वचालित रूप से काम करता है।

आउटपुट प्राप्त करना

डिफ़ॉल्ट रूप से, masscan काफी बड़ी टेक्स्ट फ़ाइलें उत्पन्न करता है, लेकिन उन्हें किसी भी अन्य प्रारूप में परिवर्तित करना आसान है। पाँच समर्थित आउटपुट प्रारूप हैं:

1. xml: बस पैरामीटर -oX <filename> का उपयोग करें। या, पैरामीटर --output-format xml और --output-filename <filename> का उपयोग करें।

2. binary: यह masscan का अंतर्निहित प्रारूप है। यह बहुत छोटी फ़ाइलें उत्पन्न करता है ताकि जब मैं इंटरनेट स्कैन करूं तो मेरी डिस्क भर न जाए। हालांकि, उन्हें पार्स करने की आवश्यकता होती है। कमांड-लाइन विकल्प --readscan बाइनरी स्कैन फ़ाइलों को पढ़ेगा। -oX विकल्प के साथ --readscan का उपयोग करने से परिणाम फ़ाइल का XML संस्करण तैयार होगा।

3. grepable: यह Nmap -oG आउटपुट का एक कार्यान्वयन है जिसे कमांड-लाइन टूल द्वारा आसानी से पार्स किया जा सकता है। बस पैरामीटर -oG <filename> का उपयोग करें। या, पैरामीटर --output-format grepable और --output-filename <filename> का उपयोग करें।

4. json: यह परिणामों को JSON प्रारूप में सहेजता है। बस पैरामीटर -oJ <filename> का उपयोग करें। या, पैरामीटर --output-format json और का उपयोग करें।

Nmap से तुलना

जहां उचित हो, प्रोग्राम को nmap उपयोगकर्ताओं से परिचित बनाने का हर प्रयास किया गया है, भले ही यह मौलिक रूप से भिन्न हो। Masscan बहुत सी मशीनों की व्यापक श्रेणी के स्कैनिंग के लिए ट्यून किया गया है, जबकि nmap एकल मशीन या छोटी सीमा की गहन स्कैनिंग के लिए डिज़ाइन किया गया है।

दो महत्वपूर्ण अंतर हैं:

• स्कैन करने के लिए कोई डिफ़ॉल्ट पोर्ट नहीं, आपको -p <ports> निर्दिष्ट करना होगा
• लक्ष्य होस्ट IP पते या सरल श्रेणियाँ हैं, DNS नाम नहीं, न ही वो अजीब सबनेट श्रेणियाँ जो nmap उपयोग कर सकता है (जैसे 10.0.0-255.0-255)।

आप masscan में निम्नलिखित सेटिंग्स स्थायी रूप से सक्षम समझ सकते हैं:

• -sS: यह केवल SYN स्कैन करता है (वर्तमान में, भविष्य में बदल जाएगा)
• -Pn: पहले होस्ट को पिंग नहीं करता, जो एसिंक ऑपरेशन के लिए मौलिक है
• -n: कोई DNS रिज़ॉल्यूशन नहीं होता
• --randomize-hosts: स्कैन पूरी तरह से यादृच्छिक, हमेशा, आप इसे बदल नहीं सकते
• --send-eth: रॉ libpcap का उपयोग करके भेजता है

यदि आप अतिरिक्त nmap संगत सेटिंग्स की सूची चाहते हैं, तो निम्नलिखित कमांड का उपयोग करें:

# masscan --nmap

संचरण दर (महत्वपूर्ण!!)

यह प्रोग्राम बहुत तेज़ी से पैकेट बाहर निकालता है। Windows पर, या VM से, यह 300,000 पैकेट/सेकंड कर सकता है। Linux पर (कोई वर्चुअलाइजेशन नहीं) यह 1.6 मिलियन पैकेट-प्रति-सेकंड करेगा। यह अधिकांश नेटवर्क को पिघलाने के लिए पर्याप्त तेज़ है।

ध्यान दें कि यह केवल आपके अपने नेटवर्क को पिघलाएगा। यह लक्ष्य IP पतों को यादृच्छिक करता है ताकि यह किसी दूरस्थ नेटवर्क को अभिभूत न करे।

डिफ़ॉल्ट रूप से, दर 100 पैकेट/सेकंड पर सेट है। दर को एक मिलियन तक बढ़ाने के लिए --rate 1000000 जैसा कुछ उपयोग करें।

IPv4 इंटरनेट को स्कैन करते समय, आप बहुत सारे सबनेट स्कैन कर रहे होंगे, इसलिए भले ही बाहर जाने वाले पैकेटों की उच्च दर हो, प्रत्येक लक्ष्य सबनेट को आने वाले पैकेटों की एक छोटी दर प्राप्त होगी।

हालांकि, IPv6 स्कैनिंग के साथ, आप अरबों पतों वाले एकल लक्ष्य सबनेट पर ध्यान केंद्रित करेंगे। इस प्रकार, आपका डिफ़ॉल्ट व्यवहार लक्ष्य नेटवर्क को अभिभूत कर देगा। masscan द्वारा उत्पन्न किए जा सकने वाले लोड के तहत नेटवर्क अक्सर क्रैश हो जाते हैं।

डिज़ाइन

यह खंड प्रोग्राम के प्रमुख डिज़ाइन मुद्दों का वर्णन करता है।

कोड लेआउट

फ़ाइल main.c में main() फ़ंक्शन होता है, जैसा कि आप उम्मीद करेंगे। इसमें transmit_thread() और receive_thread() फ़ंक्शन भी शामिल हैं। इन फ़ंक्शनों को जानबूझकर समतल किया गया है और भारी टिप्पणी की गई है ताकि आप इनमें से प्रत्येक के माध्यम से पंक्ति-दर-पंक्ति चलकर प्रोग्राम के डिज़ाइन को पढ़ सकें।

अतुल्यकालिक

यह एक अतुल्यकालिक डिज़ाइन है। दूसरे शब्दों में, यह nmap के लिए वैसा ही है जैसा nginx वेब-सर्वर Apache के लिए है। इसमें अलग-अलग ट्रांसमिट और रिसीव थ्रेड हैं जो एक-दूसरे से काफी हद तक स्वतंत्र हैं। यह उसी प्रकार का डिज़ाइन है जो scanrand, unicornscan, और ZMap में पाया जाता है।

क्योंकि यह अतुल्यकालिक है, यह उतनी ही तेजी से चलता है जितनी अंतर्निहित पैकेट ट्रांसमिट अनुमति देता है।

यादृच्छिकीकरण

Masscan और अन्य स्कैनर के बीच एक मुख्य अंतर लक्ष्यों को यादृच्छिक करने का तरीका है।

मूल सिद्धांत एक एकल इंडेक्स वेरिएबल होना है जो शून्य से शुरू होता है और प्रत्येक प्रोब के लिए एक से बढ़ता है। C कोड में, इसे इस प्रकार व्यक्त किया गया है:

for (i = 0; i < range; i++) {
    scan(i);
}

हमें इंडेक्स को IP पते में अनुवाद करना होगा। मान लें कि आप सभी "निजी" IP पतों को स्कैन करना चाहते हैं। वह इस तरह की श्रेणियों की तालिका होगी:

192.168.0.0/16
10.0.0.0/8
172.16.0.0/12

इस उदाहरण में, पहले 64k इंडेक्स लक्ष्य पता बनाने के लिए 192.168.x.x से जोड़े जाते हैं। फिर, अगले 16-मिलियन 10.x.x.x से जोड़े जाते हैं। श्रेणी में शेष इंडेक्स 172.16.x.x पर लागू होते हैं।

इस उदाहरण में, हमारे पास केवल तीन श्रेणियाँ हैं। पूरे इंटरनेट को स्कैन करते समय, हमारे पास व्यवहार में 100 से अधिक श्रेणियाँ होती हैं। ऐसा इसलिए है क्योंकि आपको बहुत सारी उप-श्रेणियों को ब्लैकलिस्ट या बहिष्कृत करना होता है। यह वांछित श्रेणी को सैकड़ों छोटी श्रेणियों में काट देता है।

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

हम इंडेक्स से IP पते में अनुवाद करने वाले फ़ंक्शन को pick() फ़ंक्शन कहते हैं। उपयोग में, यह इस प्रकार दिखता है:

for (i = 0; i < range; i++) {
    ip = pick(addresses, i);
    scan(ip);
}

Masscan न केवल IP पते की श्रेणियों, बल्कि पोर्ट श्रेणियों का भी समर्थन करता है। इसका मतलब है कि हमें इंडेक्स वेरिएबल से एक IP पता और एक पोर्ट दोनों चुनने की आवश्यकता है। यह काफी सीधा है:

range = ip_count * port_count;
for (i = 0; i < range; i++) {
    ip   = pick(addresses, i / port_count);
    port = pick(ports,     i % port_count);
    scan(ip, port);
}

यह कोड के एक और महंगे हिस्से की ओर ले जाता है। x86 CPU पर डिवीजन/मॉड्यूलस निर्देश लगभग 90 क्लॉक साइकिल, या 30 नैनोसेकंड के होते हैं। 10 मिलियन पैकेट/सेकंड की दर से संचारित करते समय, हमारे पास प्रति पैकेट केवल 100 नैनोसेकंड होते हैं। मैं इसे और बेहतर ढंग से अनुकूलित करने का कोई तरीका नहीं देखता। सौभाग्य से, हालांकि, ऐसे दो ऑपरेशन एक साथ निष्पादित किए जा सकते हैं, इसलिए ऊपर दिखाए अनुसार इनमें से दो करना एक करने से अधिक महंगा नहीं है।

उपरोक्त प्रदर्शन समस्याओं के लिए वास्तव में कुछ आसान अनुकूलन हैं, लेकिन वे सभी i++ पर निर्भर करते हैं, इस तथ्य पर कि इंडेक्स वेरिएबल स्कैन के माध्यम से एक-एक करके बढ़ता है। वास्तव में, हमें इस वेरिएबल को यादृच्छिक करने की आवश्यकता है। हमें उन IP पतों के क्रम को यादृच्छिक करने की आवश्यकता है जिन्हें हम स्कैन करते हैं अन्यथा हम लक्ष्य नेटवर्क को बुरी तरह से प्रभावित करेंगे जो गति के इस स्तर के लिए नहीं बने हैं। हमें अपने ट्रैफ़िक को लक्ष्य पर समान रूप से फैलाने की आवश्यकता है।

हम जिस तरह से यादृच्छिक करते हैं वह केवल इंडेक्स वेरिएबल को एन्क्रिप्ट करके है। परिभाषा के अनुसार, एन्क्रिप्शन यादृच्छिक होता है और मूल इंडेक्स वेरिएबल और आउटपुट के बीच 1-से-1 मैपिंग बनाता है। इसका मतलब है कि जब हम रैखिक रूप से श्रेणी के माध्यम से जाते हैं, तो आउटपुट IP पते पूरी तरह से यादृच्छिक होते हैं। कोड में, यह इस तरह दिखता है:

range = ip_count * port_count;
for (i = 0; i < range; i++) {
    x = encrypt(i);
    ip   = pick(addresses, x / port_count);
    port = pick(ports,     x % port_count);
    scan(ip, port);
}

इसकी भी एक बड़ी लागत है। चूंकि श्रेणी एक सुंदर सम घात 2 के बजाय एक अप्रत्याशित आकार है, हम AND (&) और XOR (^) जैसी सस्ती बाइनरी तकनीकों का उपयोग नहीं कर सकते। इसके बजाय, हमें MODULUS (%) जैसी महंगी क्रियाओं का उपयोग करना होगा। मेरे वर्तमान बेंचमार्क में, वेरिएबल को एन्क्रिप्ट करने में 40 नैनोसेकंड लग रहे हैं।

यह आर्किटेक्चर बहुत सारी शानदार सुविधाओं की अनुमति देता है। उदाहरण के लिए, यह "शार्ड्स" का समर्थन करता है। आप 5 मशीनें सेट कर सकते हैं, प्रत्येक स्कैन का पाँचवाँ हिस्सा या range / shard_count कर सकती है। शार्ड्स कई मशीनें, या बस एक ही मशीन पर कई नेटवर्क एडेप्टर, या (यदि आप चाहें) एक ही नेटवर्क एडेप्टर पर कई IP स्रोत पते हो सकते हैं।

या, आप एन्क्रिप्शन फ़ंक्शन के लिए 'सीड' या 'की' का उपयोग कर सकते हैं, ताकि हर बार स्कैन करने पर आपको एक अलग क्रम मिले, जैसे x = encrypt(seed, i)।

हम प्रोग्राम से बाहर निकलकर, और बस i के वर्तमान मान को याद करके, और बाद में इसे पुनरारंभ करके स्कैन को रोक सकते हैं। मैं विकास के दौरान ऐसा बहुत करता हूं। मैं देखता हूं कि मेरे इंटरनेट स्कैन में कुछ गलत हो रहा है, इसलिए मैं स्कैन को रोकने के लिए दबाता हूं, फिर बग ठीक करने के बाद इसे पुनरारंभ करता हूं।

एक अन्य सुविधा पुनर्प्रेषण/पुनर्प्रयास है। इंटरनेट पर कभी-कभी पैकेट ड्रॉप हो जाते हैं, इसलिए आप दो पैकेट बैक-टू-बैक भेज सकते हैं। हालांकि, जो चीज एक पैकेट को गिराती है वह तुरंत बाद वाले पैकेट को भी गिरा सकती है। इसलिए, आप कॉपी को लगभग 1 सेकंड के अंतराल पर भेजना चाहते हैं। यह सरल है। हमारे पास पहले से ही एक 'रेट' वेरिएबल है, जो पैकेट-प्रति-सेकंड दर है जिस पर हम संचारित कर रहे हैं, इसलिए पुनर्प्रेषण फ़ंक्शन केवल i + rate को इंडेक्स के रूप में उपयोग करना है। इन्हीं दिनों मैं इंटरनेट का एक अध्ययन करने जा रहा हूं, और यह देखने के लिए कि क्या गिरने में कोई अंतर है, "बैक-टू-बैक", "1 सेकंड", "10 सेकंड", और "1 मिनट" पुनर्प्रेषणों को इस तरह अलग करूंगा।

C10 स्केलेबिलिटी

अतुल्यकालिक तकनीक को "c10k समस्या" के समाधान के रूप में जाना जाता है। Masscan को स्केलेबिलिटी के अगले स्तर, "C10M समस्या" के लिए डिज़ाइन किया गया है।

C10M समाधान कर्नेल को बायपास करना है। Masscan में तीन प्राथमिक कर्नेल बाईपास हैं:

• कस्टम नेटवर्क ड्राइवर
• उपयोगकर्ता-मोड TCP स्टैक
• उपयोगकर्ता-मोड सिंक्रनाइज़ेशन

Masscan PF_RING DNA ड्राइवर का उपयोग कर सकता है। यह ड्राइवर शून्य कर्नेल भागीदारी के साथ उपयोगकर्ता-मोड मेमोरी से सीधे नेटवर्क ड्राइवर को पैकेट DMA करता है। यह सॉफ्टवेयर को, धीमे CPU के साथ भी, हार्डवेयर द्वारा अनुमत अधिकतम दर पर पैकेट संचारित करने की अनुमति देता है। यदि आप एक कंप्यूटर में 8 10-जीबीपीएस नेटवर्क कार्ड लगाते हैं, तो इसका मतलब है कि यह 100-मिलियन पैकेट/सेकंड की दर से संचारित कर सकता है।

Masscan में TCP कनेक्शन से बैनर प्राप्त करने के लिए अपना स्वयं का अंतर्निहित TCP स्टैक है। इसका मतलब है कि यह आसानी से 10 मिलियन समवर्ती TCP कनेक्शन का समर्थन कर सकता है, बशर्ते कि कंप्यूटर में पर्याप्त मेमोरी हो।

Masscan में कोई "mutex" नहीं है। आधुनिक mutex (उर्फ futex) अधिकतर उपयोगकर्ता-मोड में होते हैं, लेकिन उनमें दो समस्याएं हैं। पहली समस्या यह है कि वे कैश-लाइनों को CPU के बीच तेजी से आगे-पीछे उछालने का कारण बनते हैं। दूसरी यह है कि जब विवाद होता है, तो वे कर्नेल में एक सिस्टम कॉल करेंगे, जो प्रदर्शन को मार देता है। किसी प्रोग्राम के फास्ट पथ पर mutex स्केलेबिलिटी को गंभीर रूप से सीमित करता है। इसके बजाय, Masscan चीजों को सिंक्रनाइज़ करने के लिए "रिंग्स" का उपयोग करता है, जैसे जब रिसीव थ्रेड में उपयोगकर्ता-मोड TCP स्टैक को ट्रांसमिट थ्रेड में हस्तक्षेप किए बिना एक पैकेट संचारित करने की आवश्यकता होती है।

पोर्टेबिलिटीकोड Linux, Windows, और Mac OS X पर अच्छी तरह से चलता है। सभी महत्वपूर्ण भाग मानक C (C90) में हैं। इसलिए, यह Visual Studio में Microsoft के कंपाइलर, Mac OS X पर Clang/LLVM कंपाइलर, और Linux पर GCC के साथ संकलित होता है।

Windows और Mac पैकेट ट्रांसमिट के लिए ट्यून नहीं किए गए हैं, और केवल लगभग 300,000 पैकेट प्रति सेकंड प्राप्त करते हैं, जबकि Linux 1,500,000 पैकेट/सेकंड कर सकता है। यह शायद वैसे भी आपकी ज़रूरत से तेज़ है।

Safe code

कमजोरियों के लिए इनाम की पेशकश की जाती है, अधिक जानकारी के लिए VULNINFO.md फ़ाइल देखें।

यह प्रोजेक्ट strcpy() जैसे असुरक्षित फ़ंक्शन के बजाय safe_strcpy() जैसे सुरक्षित फ़ंक्शन का उपयोग करता है।

इस प्रोजेक्ट में स्वचालित यूनिट रिग्रेशन परीक्षण हैं (make regress)।

Compatibility

इनपुट/आउटपुट को nmap जैसा दिखाने के लिए बहुत प्रयास किए गए हैं, जिससे हर कोई जो पोर्ट स्कैन करता है, परिचित है (या होना चाहिए)।

IPv6 and IPv4 coexistence

Masscan IPv6 का समर्थन करता है, लेकिन कोई विशेष मोड नहीं है, दोनों एक ही समय में समर्थित हैं। (कोई -6 विकल्प नहीं है -- यह हमेशा उपलब्ध है)।

Masscan उपयोग के किसी भी उदाहरण में, जहाँ आप IPv4 पता देखते हैं, वहाँ बस एक IPv6 पता डालें। आप एक ही स्कैन में IPv4 और IPv6 पतों को एक साथ शामिल कर सकते हैं। आउटपुट में उसी स्थान पर उपयुक्त पता शामिल होता है, बिना किसी विशेष चिह्न के।

बस याद रखें कि IPv6 पता स्थान वास्तव में बड़ा है। आप शायद बड़ी रेंज को स्कैन नहीं करना चाहेंगे, सिवाय शायद किसी सबनेट के पहले 64k पतों के जो DHCPv6 के माध्यम से असाइन किए गए थे।

इसके बजाय, आप शायद एक फ़ाइल (--include-file filename.txt) में संग्रहीत पतों की बड़ी सूचियों को स्कैन करना चाहेंगे जो आपको अन्य स्रोतों से मिली हैं। हर जगह की तरह, इस फ़ाइल में IPv4 और IPv6 दोनों पतों की सूचियाँ हो सकती हैं। मैं जिस परीक्षण फ़ाइल का उपयोग करता हूँ उसमें 8 मिलियन पते हैं। उस आकार की फ़ाइलों को स्टार्टअप पर पढ़ने में कुछ अतिरिक्त सेकंड लगते हैं (masscan स्कैन करने से पहले पतों को सॉर्ट करता है और डुप्लिकेट हटाता है)।

याद रखें कि masscan में अपना स्वयं का नेटवर्क स्टैक है। इस प्रकार, जिस स्थानीय मशीन से आप masscan चलाते हैं, उसे IPv6 सक्षम होने की आवश्यकता नहीं है -- हालाँकि स्थानीय नेटवर्क को IPv6 पैकेट रूट करने में सक्षम होना चाहिए।

PF_RING

2 मिलियन पैकेट/सेकंड से आगे जाने के लिए, आपको एक Intel 10-gbps Ethernet एडाप्टर और ntop से "PF_RING ZC" के रूप में जाना जाने वाला एक विशेष ड्राइवर चाहिए। PF_RING का उपयोग करने के लिए Masscan को पुनर्निर्माण करने की आवश्यकता नहीं है। PF_RING का उपयोग करने के लिए, आपको निम्नलिखित घटकों का निर्माण करना होगा:

• libpfring.so (/usr/lib/libpfring.so में स्थापित)
• pf_ring.ko (उनका कर्नेल ड्राइवर)
• ixgbe.ko (Intel 10-gbps Ethernet ड्राइवर का उनका संस्करण)

आपको libpcap.so का उनका संस्करण बनाने की आवश्यकता नहीं है।

जब Masscan पता लगाता है कि कोई एडाप्टर enp1s0 जैसे कुछ के बजाय zc:enp1s0 जैसे कुछ नाम से है, तो यह स्वचालित रूप से PF_RING ZC मोड में स्विच हो जाएगा।

अधिक विस्तृत चर्चा PoC||GTFO 0x15 में पाई जा सकती है।

Regression testing

प्रोजेक्ट में एक अंतर्निहित यूनिट परीक्षण है:

$ make test
bin/masscan --selftest
selftest: success!

यह कोड के कई पेचीदा भागों का परीक्षण करता है। आपको निर्माण के बाद ऐसा करना चाहिए।

Performance testing

प्रदर्शन का परीक्षण करने के लिए, अपने स्थानीय राउटर को ओवरलोड करने से बचने के लिए एक थ्रो-अवे पते पर निम्नलिखित जैसा कुछ चलाएँ:

$ bin/masscan 0.0.0.0/4 -p80 --rate 100000000 --router-mac 66-55-44-33-22-11

नकली --router-mac पैकेट को स्थानीय नेटवर्क सेगमेंट पर रखता है ताकि वे इंटरनेट पर न जाएँ।

आप "ऑफ़लाइन" मोड में भी परीक्षण कर सकते हैं, जो बताता है कि ट्रांसमिट ओवरहेड के बिना प्रोग्राम कितनी तेज़ी से चलता है:

$ bin/masscan 0.0.0.0/4 -p80 --rate 100000000 --offline

यह दूसरा बेंचमार्क मोटे तौर पर दिखाता है कि यदि प्रोग्राम PF_RING का उपयोग कर रहा होता, जिसमें लगभग शून्य ओवरहेड है, तो वह कितनी तेज़ी से चलेगा।

वैसे, रैंडमाइजेशन एल्गोरिथ्म "पूर्णांक अंकगणित" का भारी उपयोग करता है, जो CPU पर एक पुरानी धीमी संक्रिया है। आधुनिक CPUs ने इस गणना को करने की गति को दोगुना कर दिया है, जिससे masscan बहुत तेज़ हो गया है।

Authors

यह टूल Robert Graham द्वारा बनाया गया: ईमेल: [email protected] ट्विटर: @ErrataRob

License

Copyright (c) 2013 Robert David Graham

This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, version 3 of the License.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License along with this program. If not, see https://www.gnu.org/licenses/.