समस्या का सार
एक ईथरनेट नेटवर्क के सबसे खराब दस्तों में से एक तथाकथित लूप है। वे तब उत्पन्न होते हैं जब (मुख्य रूप से मानव कारक के कारण) नेटवर्क टोपोलॉजी में एक रिंग बनता है। उदाहरण के लिए, दो स्विच पोर्ट पैच कॉर्ड के साथ जुड़े हुए थे (यह अक्सर तब होता है जब दो स्विच एक द्वारा प्रतिस्थापित किए जाते हैं और बिना देखे वे सब कुछ चिपका देते हैं) या उन्होंने एक नई लाइन पर नोड शुरू किया, लेकिन वे पुराने को डिस्कनेक्ट करना भूल गए (परिणाम दुखद और पहचान करने में मुश्किल हो सकते हैं)। इस तरह के एक लूप के परिणामस्वरूप, पैकेट गुणा करना शुरू करते हैं, स्विचिंग टेबल खो जाते हैं, और एक हिमस्खलन-जैसे यातायात शुरू होता है। ऐसी स्थितियों में, नेटवर्क उपकरण जमा देता है और नेटवर्क का पूर्ण विघटन होता है।
इन छोरों के अलावा, यह असामान्य नहीं है कि जब कोई पोर्ट (स्विच या नेटवर्क कार्ड) जलता है, तो उसे प्राप्त पैकेट वापस नेटवर्क पर लौटना शुरू हो जाता है, और सबसे अधिक बार कनेक्शन 10 एम पर बातचीत की जाती है, और केबल के डिस्कनेक्ट होने पर भी लिंक ऊपर जाता है। जब एक सेगमेंट में केवल एक पोर्ट होता है, तो परिणाम इतने निराशाजनक नहीं हो सकते हैं, लेकिन वे अभी भी बहुत संवेदनशील हैं (विस्टा और सात के उपयोगकर्ता विशेष रूप से बुरी तरह से पीड़ित हैं)। किसी भी मामले में, ऐसी चीजों के साथ आपको निर्दयता से लड़ने और इस तथ्य को समझने की आवश्यकता है कि जानबूझकर या गलती से एक लूप बनाकर, थोड़े समय के लिए, आप पूरे नेटवर्क सेगमेंट को डिस्कनेक्ट कर सकते हैं।
materiel
सौभाग्य से, अधिकांश आधुनिक प्रबंधित स्विच, एक या दूसरे रूप में, लूप डिटेक्शन फ़ंक्शंस (लूपडेट, स्टेप), और इससे भी अधिक, प्रोटोकॉल का stp परिवार आपको विशेष रूप से एक रिंग टोपोलॉजी (दोष सहिष्णुता और विश्वसनीयता बढ़ाने के लिए) बनाने की अनुमति देता है। लेकिन सिक्का के लिए एक फ्लिप पक्ष है, यह अक्सर ऐसा होता है कि एक जला हुआ बंदरगाह संचार के बिना पूरे क्षेत्र को छोड़ सकता है। या, कहें, एक ही stp पर, टोपोलॉजी को फिर से नहीं बनाया गया है, इस क्षण का कनेक्शन, निश्चित रूप से, वांछित होने के लिए बहुत कुछ छोड़ देता है। इसके अलावा, कुछ निर्माता लूप डिटेक्शन प्रोटोकॉल के कार्यान्वयन में बहुत लापरवाही करते हैं, कहते हैं कि DES-3016 (ग्लिंक) एक लूप का निर्धारण नहीं कर सकता है यदि आप बस इसके दो बंदरगाहों को जोड़ते हैं।
पहचान के सिद्धांत
लूप डिटेक्शन (लूपडेट) का सिद्धांत काफी सरल है। एक विशेष पैकेट एक प्रसारण पते (सभी के लिए इरादा) के साथ नेटवर्क को भेजा जाता है और अगर यह वापस जाता है, तो हम मानते हैं कि इस इंटरफ़ेस के पीछे का नेटवर्क वापस लूप किया गया है। आगे क्या करना है यह उपकरण और सेटिंग्स के प्रकार पर निर्भर करता है। सबसे अधिक बार, पोर्ट पूरी तरह या आंशिक रूप से (एक अलग vlan में) अवरुद्ध होता है, ईवेंट लॉग होता है, स्नैम्प ट्रैप भेजे जाते हैं। यह वह जगह है जहाँ सिस्टम प्रशासक और आपातकालीन सेवा आते हैं।
यदि पूरा नेटवर्क प्रबंधनीय है, तो लूप की पहचान करना और उसे खत्म करना मुश्किल नहीं है। लेकिन इतने कम नेटवर्क नहीं हैं जहां एक पोर्ट से 5-6 मानवरहित स्विचों की श्रृंखला जुड़ी हो। ऐसे लूप को हटाने में बहुत समय और प्रयास लग सकता है। खोज प्रक्रिया बंदरगाहों को क्रमिक रूप से अक्षम (सक्षम) करने के लिए उबलती है। एक लूप की उपस्थिति का निर्धारण करने के लिए, एक बेहतर प्रबंधित स्विच या कुछ स्निफर (वायरशार्क, टीसीपीडंप) का उपयोग किया जाता है। लॉक को चालू और बंद करने के बीच देरी के कारण पहली विधि बहुत खतरनाक है, सर्वश्रेष्ठ मामले में, उपयोगकर्ताओं के पास बस अंतराल होगा, और सबसे खराब स्थिति में, एक लूपडेट लाइन में अधिक काम करेगा और एक बड़ा खंड बंद हो जाएगा। दूसरे मामले में, उपयोगकर्ताओं के लिए कोई खतरा नहीं है, लेकिन लूप की उपस्थिति को निर्धारित करना अधिक कठिन है (विशेषकर एक छोटे से खंड में जहां थोड़ा प्रसारण होता है), फिर भी स्निफर चीज परिभाषा से, निष्क्रिय है।
इसे स्वयं करें
जैसा कि ऊपर उल्लेख किया गया है, लूप खोज का हार्डवेयर कार्यान्वयन पर्याप्त से अधिक है। तो बिना किसी हिचकिचाहट के, मैं वॉशर्सक को चालू करता हूं, फिल्टर को कॉन्फ़िगर करता हूं और देखता हूं कि स्विच क्या और कैसे करता है। वास्तव में, सब कुछ सरल है: एक ईथरनेट पैकेट गंतव्य पते के साथ पोर्ट पर भेजा जाता है
cf: 00: 00: 00: 00: 00 , टाइप
0x9000 (
CTP ) और एक अज्ञात फ़ंक्शन संख्या 256 के साथ (केवल दो दस्तावेज मुझे मिले हैं) में वर्णित हैं। गंतव्य का पता एक प्रसारण है, इसलिए यदि नेटवर्क में लूप हैं, तो इस पैकेट की कई प्रतियां वापस जानी चाहिए।
पहले पुस्तकालयों पर फैसला किया:
- कच्चे पैकेट पर कब्जा करने और भेजने के लिए मैं पीसीआई लाइब्रेरी का उपयोग करूंगा;
- पैकेज जनरेशन के साथ dpkt मेरी मदद करेगा;
- ध्वनि बजाने के लिए, मैं प्यूदेओ और लहर का उपयोग करूँगा;
- खैर, कुछ मानक पुस्तकालयों।
इसके अलावा, सब कुछ आसान और सरल है। मैं चयनित इंटरफ़ेस के साथ pcapy.open_live वर्ग का एक उदाहरण बनाता हूं और इसमें एक फिल्टर जोड़ता हूं। मैं पहला लूप बनाता हूं जो समय-समय पर एक पैकेट भेजेगा, और इसके अंदर एक दूसरा होगा, जो लौटे पैकेट को कैप्चर और प्रोसेस करेगा। यदि कब्जा किया गया पैकेट भेजे गए के समान है, तो काउंटर में +1 जोड़ा जाता है। यदि टाइमआउट समाप्त होने के बाद पैकेट की एक से अधिक प्रतिलिपि प्राप्त होती है, तो एक ध्वनि बजाई जाती है, और कंसोल पर एक लूप संदेश प्रदर्शित किया जाता है।
परिणामी स्क्रिप्ट बाद में मिल सकती है।
import pcapy, dpkt , sys import time , random, socket import pyaudio , wave def packetBody(length): rez = [] for x in range(0,length): rez.append(random.choice('0123456789abcdef') + random.choice('0123456789abcdef')) return rez class loopDetector: packetCount = 0 loopCount = 0 timeout = 1 def __init__(self,iface): self.iface = iface self.pcaper = pcapy.open_live(iface,100,1,500) self.Mac = '00:19:5b:'+':'.join(packetBody(3)) self.pcaper.setfilter('ether dst cf:00:00:00:00:00 and ether src %s' % self.Mac) wf = wave.open('alarm.wav', 'rb') self.pyA = pyaudio.PyAudio() self.stream = self.pyA.open(format = self.pyA.get_format_from_width(wf.getsampwidth()), channels = wf.getnchannels(), rate = wf.getframerate(), output = True) self.wfData = wf.readframes(100000) wf.close() def __del__(self): self.stream.stop_stream() self.stream.close() self.pyA.terminate() def PlayAlarm(self): self.stream.write(self.wfData) def Capture(self,hdr,data): if data == str(self.sPkt): self.packetReceived += 1 def Process(self): while 1: try: pktData = '00000001' + ''.join(packetBody(42)) self.sPkt = dpkt.ethernet.Ethernet(dst="cf0000000000".decode('hex'), src=''.join(self.Mac.split(':')).decode('hex'), type=36864,data=pktData.decode('hex')) endTime = time.time() + self.timeout print "Send packet to %s" % self.iface self.packetCount += 1 self.pcaper.sendpacket(str(self.sPkt)) self.packetReceived = 0 while time.time() < endTime: try: self.pcaper.dispatch(-1,self.Capture) except socket.timeout: pass if self.packetReceived > 1: self.loopCount += 1 print "Loop Detected. Duplication found %s" % self.packetReceived self.PlayAlarm() except KeyboardInterrupt: break print "Packets sent: ", self.packetCount , "Loops discovered : " , self.loopCount def main(): dev_list = {} n = 0 iface = '' for x in pcapy.findalldevs(): dev_list[n] = x n += 1 try: iface = dev_list[0] except KeyError: print "No device found" exit(1) if len(sys.argv) == 2: try: if sys.argv[1] in ['list','ls','all']: for x in dev_list: print 'Index:', x, 'Device name:' ,dev_list[x] return 0 else: iface = dev_list[int(sys.argv[1])] except KeyError: print "Invalid device id, trying use first" iface = dev_list[0] ld = loopDetector(iface) ld.Process() if __name__ == "__main__": main()
मूल और स्रोत से लिंक करें