हम पायथन के लिए एक मॉड्यूल के रूप में एक पागल निष्क्रिय स्निफर कोड करते हैं

मुझे तुरंत कहना चाहिए: हम यहां क्या कर रहे हैं, किसी भी औद्योगिक प्रयोज्यता का ढोंग नहीं करना चाहिए। इसके अलावा, मैं स्वीकार करता हूं कि इस उदाहरण में मेरा कोड भयानक, डरावना और अनावश्यक हो सकता है। और फिर भी - सप्ताह के मध्य में पैकेट को क्यों नहीं रोकना चाहिए? तो, हल्के ढंग से।

इसलिए आज हम इसे पूरा करेंगे:

1. हम टीसीपी और यूडीपी के लिए सबसे सरल निष्क्रिय पैकेट स्निफर को लागू करते हैं
2. इसे पायथन के विस्तार के रूप में सी-लाइब्रेरी में डालें
3. हम यह सब करने के लिए एक इटरेटर इंटरफ़ेस संलग्न करते हैं ताकि बाइट्स कॉर्नुकोपिया की तरह बिखरे रहें
4. ...
5. लाभ!

यह सब क्यों जरूरी है?

हमें स्निफर्स की आवश्यकता क्यों है? नेटवर्क ट्रैफिक सूँघने के लिए। नहीं, मैं मजाक नहीं कर रहा हूं, अंग्रेजी क्रिया "सूंघने के लिए" का अनुवाद "सूंघना" है। ठीक है, ठीक है, हम और अधिक वैज्ञानिक होंगे - उनकी मदद से, आपको कंप्यूटर के नेटवर्क कार्ड से गुजरने वाले नेटवर्क पैकेट का विश्लेषण करना चाहिए।

स्नाइपर निष्क्रिय और सक्रिय हैं। एक निष्क्रिय स्निफर ठीक और केवल वही करता है जो इसके लिए आवश्यक है - यह विश्लेषण ट्रैफ़िक को स्वीकार करता है जो कंप्यूटर के नेटवर्क कार्ड से गुजरता है जिस पर यह स्थापित है। यह बहुत अच्छा लगता है? हालांकि, सक्रिय स्निफर न केवल नेटवर्क कार्ड की निगरानी करता है, बल्कि उन ट्रैफ़िक को प्राप्त करने की भी कोशिश करता है जो स्थानीय नेटवर्क पर चलते हैं और आंखों को चुभने के लिए अभिप्रेत नहीं है। वह ऐसा करता है, उदाहरण के लिए, एआरपी-स्पूफिंग और अन्य सभी गंदे चालों का उपयोग करके। वैसे, गैर-स्विच किए गए नेटवर्क (रिपीटर्स और हब के आधार पर), एक निष्क्रिय स्निफर अचानक अपने आप में सुपरपावर का पता लगा सकता है, क्योंकि स्विचिंग की अनुपस्थिति में, ऐसे नेटवर्क में सभी पैकेट सभी मेजबानों को भेजे जाते हैं। बेशक, केवल प्राप्तकर्ताओं को उन्हें स्वीकार करना चाहिए, लेकिन ... :)

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



हां, कार्ड को जरूरी मोड में रखने के लिए रूट परमिशन की जरूरत होती है। इसलिए, हमारी स्क्रिप्ट उन्हें चलाने के लिए कहेगी। ऐसी बातें।

तो क्या?

जैसा कि एक प्रसिद्ध फिल्म चरित्र ने कहा, "हमें गहराई तक जाने की जरूरत है।" यही है, लिंक परत पर, ओएसआई परतों में गहराई से गोता लगाने के लिए। ऐसा करने के लिए, सॉकेट बनाते समय, आपको PF_INET के बजाय निरंतर PF_PACKET निर्दिष्ट करना होगा:

int s_sock; struct ifreq ifr; strcpy(ifr.ifr_name, IFACE); if ( (s_sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL))) < 0) { perror("Error creating socket"); exit(-1); } ifr.ifr_flags |= IFF_PROMISC; if (ioctl(s_sock, SIOCGIFFLAGS, &ifr) < 0) { perror("Unable to set promiscious mode for device"); close(s_sock); exit(-1); } 

आमतौर पर, जब आप इस तरह के सॉकेट को खोलते हैं, तो एक विशिष्ट प्रोटोकॉल का संकेत दिया जाता है, जिसके अनुसार अवरोधन होता है। यदि आप निरंतर ETH_P_ALL निर्दिष्ट करते हैं - सब कुछ इंटरसेप्ट हो जाएगा। Ifreq संरचना का उपयोग लिनक्स में नेटवर्क इंटरफ़ेस को ioctl () के माध्यम से निम्न स्तर पर चलाने के लिए किया जाता है, और इस मामले में IFACE नेटवर्क को देखने वाले इंटरफ़ेस के नाम के साथ एक स्ट्रिंग है, उदाहरण के लिए, "eth0" ।

दरअसल, अब हमारे लिए यही सब कुछ है कि हम लूप में सॉकेट से डेटा पढ़ें और देखें कि क्या होता है:

  int n = 0; char buf[MTU]; n = recvfrom(s_sock, buf, sizeof(buf), 0, 0, 0); 

यहां एमटीयू 1500 पर सेट करना सबसे आसान है - यह ईथरनेट नेटवर्क पर मानक अधिकतम पैकेट आकार है। एक और मानक के अनुसार निर्मित नेटवर्क के लिए, उदाहरण के लिए, एफडीडीआई , मान भिन्न हो सकता है।

चूंकि हम ईथरनेट के साथ काम करते हैं, इसलिए प्राप्त पैकेट के हेडर पर डेटा कर्नेल संरचना को लिखने के लिए सबसे आसान है, जिसे विशेष रूप से इस उद्देश्य के लिए डिज़ाइन किया गया है - एथेरड । ट्रांसपोर्ट लेयर तक के अलग-अलग बेसिक प्रोटोकॉल के लिए, समान संरचनाएँ हैं, जो चाहे कितनी भी कठिन क्यों न हों , उन्हें iphdr , tcphdr या udphdr की तरह कहा जाता है (जैसा कि वे कहते हैं, "मुझे HDP से एक बड़ा मज़ाक पता है, लेकिन इस तथ्य से नहीं कि यह आप तक पहुँचेगी। ")। जैसा कि अच्छे पुराने सी में अपेक्षित है, यह कुछ इस तरह करता है:

  struct ethhdr eth; memcpy((char *) &eth, data, sizeof(struct ethhdr)); 

हम्म ... और आप इसे पायथन में कैसे डालते हैं?

सभी जानते हैं कि अजगर में हम सभी को एक वस्तु होती है। जनरेटर / इटरेटर के मामले में भी कोई अपवाद नहीं होगा - हमें एक ऑब्जेक्ट बनाना होगा जिसमें __iter __ () विधि हो और आगे () कर सकते हैं। ऑब्जेक्ट में खेतों का एक गुच्छा होता है, जिनमें से अधिकांश की हमें आवश्यकता नहीं होती है, इसलिए सावधान रहें - आगे शून्य का एक गुच्छा है।

 PyTypeObject PyPacketGenerator_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "packgen", /* tp_name */ sizeof(PacketGeneratorState), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)packgen_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_reserved */ 0, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ 0, /* tp_str */ 0, /* tp_getattro */ 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT, /* tp_flags */ 0, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ PyObject_SelfIter, /* tp_iter */ (iternextfunc)packgen_next, /* tp_iternext */ 0, /* tp_methods */ 0, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ 0, /* tp_init */ PyType_GenericAlloc, /* tp_alloc */ packgen_new, /* tp_new */ }; 

यह घोषणा दिखाती है कि हमारी भविष्य की वस्तु के काम करने के तरीके packgen_new () , packgen_next (), और packgen_dealloc () हैं । उत्तरार्द्ध एक विनाशकारी है और सामान्य तौर पर, आप इसके बिना कर सकते हैं यदि आप वास्तव में चाहते हैं और स्मृति में कोई अतिरिक्त डेटा नहीं है। इसके अलावा, हमें एक संरचना की आवश्यकता है जिसमें हम वर्तमान पुनरावृत्ति पर वस्तु की स्थिति के बारे में डेटा संग्रहीत करेंगे। चूंकि केवल एक चीज जिसे हमें स्टोर करने की आवश्यकता है वह एक सॉकेट है, हम इसे घोषित करेंगे:

 typedef struct { PyObject_HEAD int s_sock; } PacketGeneratorState; 

जैसा कि मैंने ऊपर कहा था, आपको सॉकेट खोलने और नेटवर्क कार्ड को जासूस मोड में कॉन्फ़िगर करने की आवश्यकता है। ऐसा करने का सबसे आसान तरीका सीधे वस्तु आरंभीकरण विधि में है।

 static PyObject * packgen_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { int s_sock; struct ifreq ifr; strcpy(ifr.ifr_name, IFACE); if ( (s_sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL))) < 0) { perror("Error creating socket"); exit(-1); } ifr.ifr_flags |= IFF_PROMISC; if (ioctl(s_sock, SIOCGIFFLAGS, &ifr) < 0) { perror("Unable to set promiscious mode for device"); close(s_sock); exit(-1); } PacketGeneratorState *pkstate = (PacketGeneratorState *)type->tp_alloc(type, 0); if (!pkstate) return NULL; pkstate->s_sock = s_sock; return (PyObject *)pkstate; } 

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

 PyObject *packet; packet = PyDict_New(); if (!packet) return NULL; if (ntohs(eth.h_proto) == ETH_P_IP) { ip = (struct iphdr *)(data + sizeof(struct ethhdr)); PyDict_SetItemString(packet, "ip_source", PyString_FromFormat("%s", inet_ntoa(ip->saddr))); ... if ((ip->protocol) == IPPROTO_TCP) { tcp = (struct tcphdr *)(data + sizeof(struct ethhdr) + sizeof(struct iphdr)); PyDict_SetItemString(packet, "tcp_source_port", PyString_FromFormat("%d", ntohs(tcp->source))); ... } if ((ip->protocol) == IPPROTO_UDP) { udp = (struct udphdr *)(data + sizeof(struct ethhdr) + sizeof(struct iphdr)); PyDict_SetItemString(packet, "udp_source_port", PyString_FromFormat("%d", ntohs(udp->source))); ... } } return packet; 

देखा!

यह सब इस तरह दिखता है:
Python 2.7.3 (default, Apr 20 2012, 22:44:07)
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import pysniff
>>> for i in pysniff.packgen():
... print i
...
{'ip_destination': '192.168.1.111', 'tcp_seq': '10972', 'ip_source': '173.194.32.53', 'tcp_offset': '8', 'tcp_source_port': '443', 'tcp_dest_port': '44021'}
{'ip_destination': '173.194.32.53', 'tcp_seq': '47475', 'ip_source': '192.168.1.111', 'tcp_offset': '8', 'tcp_source_port': '44021', 'tcp_dest_port': '443'}
{'ip_destination': '192.168.1.111', 'tcp_seq': '10972', 'ip_source': '173.194.32.53', 'tcp_offset': '8', 'tcp_source_port': '443', 'tcp_dest_port': '44021'}
{'ip_destination': '173.194.32.53', 'tcp_seq': '47475', 'ip_source': '192.168.1.111', 'tcp_offset': '8', 'tcp_source_port': '44021', 'tcp_dest_port': '443'}

मस्ती के लिए, जीथब पर एक भंडार बनाया, क्या होगा यदि आप एक विचार विकसित करना चाहते हैं? एक अच्छा सूँघना है, पकड़ा नहीं है!