Wireshark के लिए एक विच्छेदक प्लगइन लिखना

नेटवर्क प्रोटोकॉल के साथ काम करते समय नेटवर्क को वायरटैप करने के लिए विंडशार्क अपरिहार्य उपयोगिताओं में से एक है। कार्यक्रम में पहले से ही एक निश्चित संख्या में ¹ विघटनकर्ता शामिल हैं, जो बुनियादी प्रोटोकॉल के विस्तार पैकेजों की जांच करने में मदद करते हैं। लेकिन जब मैं नॉर्टेल के मालिकाना प्रोटोकॉल पर काम कर रहा था, तो मुझे एक उपयुक्त डिसेक्टर की कमी महसूस हुई। और उसे हवा की तरह जरूरत थी। बाहर का रास्ता स्पष्ट था - अपना लिखो। जो मैंने किया।
इस प्रकार, Wireshark के तहत "एनाटोमिकल" प्लगइन लिखने का बहुत कम अनुभव होने पर, मैंने समुदाय के साथ अपने ज्ञान और अनुभव को साझा करने का निर्णय लिया। ठीक है, अपने लिए लिखें, अगर आपको भविष्य में इसकी आवश्यकता हो।

विच्छेदन - lat। विदारक, विदारक से, विच्छेद

नोट 1: लेख लिखते समय, मैंने यह मान लिया था कि पाठक Wireshark उपयोगिता से परिचित है, और यह भी जानता है कि इसकी बुनियादी सुविधाओं का उपयोग कैसे किया जाए।

नोट 2: चूंकि मैं लिनक्स के तहत काम करता हूं, इसलिए प्लगइन ने इस ओएस के लिए भी लिखा। विंडोज के तहत, मेरा प्लगइन भी संकलित किया जाना चाहिए। मुझे लगता है कि मतभेद केवल मेकफाइल्स में होंगे।

नोट 3: चूंकि मैं जिस प्रोटोकॉल पर काम कर रहा था वह मालिकाना और बंद है, साथ ही साथ एक लाख गैर-प्रकटीकरण समझौतों के कारण, इस लेख में मैं अपना, आविष्कार किया हुआ, प्रोटोकॉल मानता हूं।

फू प्रोटोकॉल

संक्षेप में, मैं आविष्कार किए गए प्रोटोकॉल का वर्णन करूंगा, जिसे मैं सीधा नाम फू कहूंगा। इस प्रोटोकॉल को UDP प्रोटोकॉल से ऊपर होने दें और निम्नलिखित संरचना हो:

• 1 बाइट - प्रोटोकॉल संस्करण
• 1 बाइट - पैकेट प्रकार
• 1 बाइट - सभी प्रकार के झंडे
• 1 बाइट - बूलियन चर के कुछ प्रकार
• 4 बाइट्स - पेलोड लंबाई
• 0 से 200 बाइट्स - पेलोड

पर्यावरण की स्थापना

इससे पहले कि आप एक प्लगइन लिखना शुरू करें, आपको कुछ डालने, कुछ बनाने, कहीं कुछ बदलने की आवश्यकता है। यहाँ है कि Wireshark स्थापित करने के लिए क्या कहता है:

• अजगर (मुझे लगता है कि कोई 2 संस्करण है, लेकिन निश्चित रूप से 3 नहीं)
• cmake
• बिजोन
• फ्लेक्स

आवश्यक पुस्तकालयों और उपयोगिताओं की एक पूरी सूची यहां है ।

आपको जो कुछ भी ज़रूरत है उसे स्थापित करने के बाद, उस संस्करण के लिए Wireshark स्रोत कोड डाउनलोड करें जिसके लिए हम प्लगइन लिखेंगे। मेरे मामले में, स्थिर शाखा के स्रोत 1.6:

$ cd $HOME $ svn co http://buildbot.wireshark.org/trunk-1.6/ wireshark 

यह सुनिश्चित करने के लिए कि संकलन काम कर रहा है, साथ ही साथ सभी आवश्यक उपयोगिताओं और पुस्तकालयों को स्थापित किया जाता है, चलाएं:

  $ cd wireshark $ ./autogen.sh $ ./configure 

यदि सब कुछ क्रम में है, तो प्लगइन्स फ़ोल्डर पर जाएं और वहां प्रोटोकॉल नाम के साथ अपना स्वयं का फ़ोल्डर बनाएं:

  $ cd $HOME/wireshark/plugins $ mkdir foo $ cd foo $ touch packet-foo.c 

ढांचा

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

पैकेट foo.c

 #ifdef HAVE_CONFIG_H # include "config.h" #endif #include <epan/packet.h> #define FOO_PORT 35000 /*  UDP ,       FOO . */ static int proto_foo = -1; /*       . */ void proto_register_foo(void) { proto_foo = proto_register_protocol ( "FOO Protocol", /*   */ "FOO", /*   */ "foo" /*  */ ); } 

शुरुआत में, हम proto_register_protocol () फ़ंक्शन को कॉल करते हैं, जो प्रोटोकॉल को पंजीकृत करता है और अपनी विशिष्ट पहचानकर्ता को लौटाता है। हम अपने प्रोटोकॉल के तीन अलग-अलग नामों को फ़ंक्शन ट्रांसफर करते हैं, जो कार्यक्रम के विभिन्न हिस्सों में प्रदर्शित किए जाएंगे। (उदाहरण के लिए, "FOO प्रोटोकॉल" और "FOO" नामों का उपयोग Wireshark सेटिंग्स में किया जाता है, और संक्षिप्त नाम "foo" का उपयोग फ़िल्टर फ़ील्ड में किया जाता है।)

अगला, हमें एक फ़ंक्शन असाइन करने की आवश्यकता है जो कि पकड़े गए फू पैकेज को डिक्रिप्ट करने के लिए आवश्यक होने पर बुलाया जाएगा। यह create_dissector_handle () फ़ंक्शन को कॉल करके किया जाता है।

 void proto_reg_handoff_foo(void) { static dissector_handle_t foo_handle; foo_handle = create_dissector_handle(dissect_foo, proto_foo); dissector_add_uint("udp.port", FOO_PORT, foo_handle); } 

यहां हम एक असंतुष्ट हैंडलर को पंजीकृत करते हैं जो संरचना के संदर्भ में प्रोटोकॉल को विघटित करने का गंदा काम करता है और इसे प्रोटो_फू प्रोटोकॉल से बांधता है। फिर हम अपने हैंडलर को UDP पोर्ट के साथ जोड़ते हैं, जिस पर हम ट्रैफ़िक जाने की उम्मीद करते हैं। इस प्रकार जब हमारे द्वारा निर्दिष्ट पोर्ट (35000) पर कुछ गतिविधि दिखाई देती है, तो विंडसर्क हमें "कॉल" करेगा।

एक एग्रीमेंट है जिसके अनुसार फंक्शंस proto_register_foo () और proto_reg_handoff_foo () हमारे सोर्स फाइल के अंत में लिखे जाने चाहिए।

अब सबसे महत्वपूर्ण बात बनी हुई है - विघटन कोड लिखने के लिए।

 static void dissect_foo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { col_set_str(pinfo->cinfo, COL_PROTOCOL, "FOO"); col_clear(pinfo->cinfo, COL_INFO); } 

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

सब कुछ, इस समय एक न्यूनतम कोड है ताकि आप सुरक्षित रूप से हमारे प्लगइन का निर्माण कर सकें और इसे Wireshark पर अपलोड कर सकें।

प्लगइन विधानसभा

बनाने के लिए (लिनक्स के लिए) हमें अपनी निर्देशिका में कुछ फाइलें प्राप्त करने की आवश्यकता है: Makefile.am, Makefile.common और modininfo.h।

• Makefile.am - UNIX / Linux फ़ाइल बनाते हैं
• Makefile.common - UNIX / लिनक्स और विंडोज के लिए जेनेरिक मेकफाइल में प्लगइन फ़ाइल नाम शामिल हैं
• Makefile.nmake - विंडोज के लिए फाइल बनाएं
• modinfo.h - में प्लगइन का संस्करण है
• modinfo.nmake - विंडोज के लिए DLL के लिए संस्करण की जानकारी है
• पैकेट- foo.c - विच्छेदक के लिए हमारा स्रोत कोड

वैसे, इतने सारे मेकफाइल्स में खुद को दफनाने के लिए आवश्यक नहीं है, क्योंकि विंडशार्क एक सरल तरीका प्रदान करता है - सीमेक का उपयोग करें। इसके कारण, फाइल बनाने की संख्या कम से कम हो जाती है। ऐसा करने के लिए, निम्न सामग्री के साथ हमारे प्लगइन के साथ फ़ोल्डर में CMakeLists.txt बनाएं:

 set(DISSECTOR_SRC packet-foo.c ) set(PLUGIN_FILES plugin.c ${DISSECTOR_SRC} ) set(CLEAN_FILES ${PLUGIN_FILES} ) if (WERROR) set_source_files_properties( ${CLEAN_FILES} PROPERTIES COMPILE_FLAGS -Werror ) endif() include_directories(${CMAKE_CURRENT_SOURCE_DIR}) register_dissector_files(plugin.c plugin ${DISSECTOR_SRC} ) add_library(foo ${LINK_MODE_MODULE} ${PLUGIN_FILES} ) set_target_properties(foo PROPERTIES PREFIX "") set_target_properties(foo PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}") target_link_libraries(foo epan) install(TARGETS foo LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/@CPACK_PACKAGE_NAME@/plugins/${CPACK_PACKAGE_VERSION} NAMELINK_SKIP RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}/@CPACK_PACKAGE_NAME@/plugins/${CPACK_PACKAGE_VERSION} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}/@CPACK_PACKAGE_NAME@/plugins/${CPACK_PACKAGE_VERSION} ) 

नोट: आप हर बार याद नहीं रख सकते कि CMakeLists.txt फाइल कैसी दिखती है, लेकिन इसे किसी भी मौजूदा प्लगइन के फ़ोल्डर से कॉपी करें, उदाहरण के लिए, इंटरलिंक। और फिर इस फ़ाइल में इंटरलिंक करने के लिए सभी संदर्भों को foo से बदलें।

फिर हमें विधानसभा प्रक्रिया के स्वचालन के लिए हमारे प्लग-इन टूल के बारे में जानकारी दें।

  $ cd $HOME/wireshark/ $ vim CMakeLists.txt 

इंडेंटेशन दिए गए लाइन "प्लग इन / फू" को जोड़ें:

 ....... if(ENABLE_PLUGINS) set(HAVE_PLUGINS 1) set(PLUGIN_DIR="${DATAFILE_DIR}/plugins/${CPACK_PACKAGE_VERSION}") set(PLUGIN_SRC_DIRS plugins/foo plugins/asn1 plugins/docsis ....... 

अब एक निर्देशिका बनाएं जिसमें संकलन और लिंकिंग के दौरान बनाई गई फ़ाइलों को संग्रहीत किया जाएगा। इसके बाद, असेंबली प्रक्रिया को स्वयं चलाएँ। निम्नलिखित कदम $ घर / वायरशर्क / निर्देशिका से किए जाते हैं

  $ mkdir build $ cd build $ cmake .. $ make foo 

सफल संकलन होने पर, हम $ होम / वायरशर्क / बिल्ड / लिब / फोल्डर में foo.so लाइब्रेरी प्राप्त करते हैं।

टेस्ट रन

फ़ाइल foo.so को /usr/lib/wireshark/plugins/1.6.0/ निर्देशिका पर कॉपी करें और Wireshark चलाएं। "सहायता -> तारों के बारे में" पर जाएं, प्लगइन्स टैब पर जाएं और दिखाई देने वाली सूची में, हमारा प्लगइन खोजें - foo .so.

यह सुनिश्चित करने के लिए कि प्लगइन हमारे प्रोटोकॉल को पहचानता है, हम पैकेट कैप्चर शुरू करते हैं और नेटवर्क पर अपने प्रोटोकॉल के साथ पैकेट भेजते हैं। (उदाहरण के लिए, मैंने UDP नेटवर्क पर एक FOO प्रोटोकॉल पैकेट भेजने वाले प्रोग्राम को व्हिप किया। इसका कोड लेख के अंत में पाया जा सकता है।)

काम करने का ढंग

अब जब हमारे पास प्लगइन ढांचा है जो अभी तक हमारे लिए उपयोगी नहीं है, लेकिन कम से कम शुरू होता है, तो हम अपने प्रोटोकॉल को "लिखेंगे"। सबसे सरल बात हम अपने प्रोटोकॉल की सीमाओं को परिभाषित कर सकते हैं।

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

 static void dissect_foo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { col_set_str(pinfo->cinfo, COL_PROTOCOL, "FOO"); col_clear(pinfo->cinfo, COL_INFO); if (tree) { proto_item *ti = NULL; ti = proto_tree_add_item(tree, proto_foo, tvb, 0, -1, FALSE); } } 

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

Proto_tree_add_item () फ़ंक्शन के पैरामीटर:

• पेड़ - हमारे पैकेज के बारे में जानकारी का पूरा पेड़
• प्रोटो_फू - हमारे प्रोटोकॉल के पहचानकर्ता
• tvb - डेटा ब्लॉक (डेटा हमारे प्रोटोकॉल द्वारा प्रेषित)
• 0 - टीवीबी ब्लॉक में डेटा हमारे फू प्रोटोकॉल का डेटा किस स्थिति से इंगित करता है
• -1 - हमारे प्रोटोकॉल द्वारा अधिमानित बाइट्स की संख्या ("-1" का अर्थ है "डेटा ब्लॉक के अंत तक")
• FALSE - बाइट ऑर्डर को इंगित करता है (TRUE - यदि बाइट्स नेटवर्क ऑर्डर में स्थित हैं।)

इन परिवर्तनों के बाद, Wireshark निर्धारित करना शुरू कर देगा कि हमारे प्रोटोकॉल का दायरा कहाँ से शुरू और समाप्त होता है और इसे "FOO प्रोटोकॉल" के रूप में चिह्नित करता है।

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

Proto_register_foo () की शुरुआत में दो स्थिर सरणियों को जोड़ें। फिर proto_register_protocol () फ़ंक्शन को कॉल करने के बाद इन सरणियों को पंजीकृत करें।

 void proto_register_foo(void) { static hf_register_info hf[] = { { &hf_foo_hdr_version, { "FOO Header Version", "foo.hdr.version", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_foo_hdr_type, { "FOO Header Type", "foo.hdr.type", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } } }; static gint *ett[] = { &ett_foo }; proto_foo = proto_register_protocol ( "FOO Protocol", "FOO", "foo" ); proto_register_field_array(proto_foo, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); } 

और वैश्विक चर प्रोटो_फू की घोषणा के ठीक बाद , 3 और घोषणाएँ जोड़ें:

 static gint ett_foo = -1; static int hf_foo_hdr_version = -1; static int hf_foo_hdr_type = -1; 

अब हम अपने प्रोटोकॉल के प्रदर्शन में सुधार करेंगे:

 if (tree) { proto_item *ti = NULL; proto_tree *foo_tree = NULL; ti = proto_tree_add_item(tree, proto_foo, tvb, 0, -1, FALSE); foo_tree = proto_item_add_subtree(ti, ett_foo); proto_tree_add_item(foo_tree, hf_foo_hdr_version, tvb, 0, 1, FALSE); proto_tree_add_item(foo_tree, hf_foo_hdr_type, tvb, 1, 1, FALSE); } 

हमारे प्रोटोकॉल के बारे में विर्सार्क का ज्ञान अब और विस्तृत हो रहा है। अब तक, हमने केवल अपने फू प्रोटोकॉल के पहले 2 बाइट्स को मान्यता दी है, जो क्रमशः प्रोटोकॉल संस्करण और पैकेट प्रकार के लिए जिम्मेदार हैं।

Proto_item_add_subtree () फ़ंक्शन के लिए कॉल ने एक अतिरिक्त शाखा ( foo_tree ) जोड़ दी जिसमें आने वाले पूरे पैकेट के बारे में जानकारी के पेड़ के लिए foo प्रोटोकॉल के बारे में विवरण है। Foo_tree में हम अपने प्रोटोकॉल का विस्तार से वर्णन करेंगे।
Wthark प्रोग्राम के आउटपुट में प्रोटोकॉल सूचना ट्री के "विस्तार" को ett_foo वेरिएबल नियंत्रित करता है। यह चर याद रखता है कि पैकेट के माध्यम से चलते समय हमारे प्रोटोकॉल को तैनात किया जाना चाहिए या नहीं।
proto_tree_add_item () इस समय वांछित प्रारूप में मूल्य को आउटपुट करने के लिए hf_foo_hdr_version चर का उपयोग करता है। hdr_version - tvb से 1 बाइट, स्थिति 0 से शुरू। hdr_type - 1 बाइट tvb से , स्थिति 1 से शुरू।

यदि हम hf_foo_hdr_version को स्थिर सरणी में देखते हैं, तो हम एक विस्तृत ट्रैक देखेंगे, जहाँ

• hf_foo_hdr_version - शाखा सूचकांक
• FOO हैडर संस्करण - फ़ील्ड नामकरण
• foo.hdr.version पैकेज फ़िल्टर करने के लिए उपयोग की जाने वाली लाइन है (इस प्रकार की लाइन फ़िल्टर फ़ील्ड में होगी)
• FT_UNIT8 - उस तत्व के प्रकार और आकार को इंगित करता है जिसे हम टीवीबी डेटा ब्लॉक से पढ़ रहे हैं। इस स्थिति में, इंगित करता है कि "प्रोटोकॉल संस्करण" फ़ील्ड 1 अहस्ताक्षरित प्रकार का पूर्णांक है। (अन्य संभावित प्रकार वायरशर्क / ईपन / फीटिप्स / फीटिप्स.एच में पाए जा सकते हैं)
• BASE_DEC - संख्यात्मक प्रकारों के लिए, इंगित करें कि किस सिस्टम में आउटपुट संख्याएँ हैं। (यह BASE_HEX या BASE_OCT भी हो सकता है। गैर-संख्यात्मक प्रकारों के लिए, BASE_NONE का उपयोग करें।)

बाकी का उपयोग कैसे करें - नीचे देखें।

अब आप फिर से प्लगइन का निर्माण कर सकते हैं और इसे Wireshark के साथ चला सकते हैं। हम देखेंगे कि विंडशार्क का उत्पादन अधिक उपयुक्त हो गया है।

ठीक है, चलो हमारे फू प्रोटोकॉल को डिकोड करने पर काम खत्म करते हैं। ऐसा करने के लिए, हमें कुछ और वैश्विक चर घोषित करने और कुछ अतिरिक्त कॉल करने की आवश्यकता है:

 ... static int hf_foo_hdr_flags = -1; static int hf_foo_hdr_bool = -1; static int hf_foo_pl_len = -1; static int hf_foo_payload = -1; ... void proto_register_foo(void) { ... { &hf_foo_hdr_flags, { "FOO Header Flags", "foo.hdr.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } }, { &hf_foo_hdr_bool, { "FOO Header Boolean", "foo.hdr.bool", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } }, { &hf_foo_pl_len, { "FOO Payload Length", "foo.pl_len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } }, { &hf_foo_payload, { "FOO Payload", "foo.payload", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } } ... } static void dissect_foo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { ... if (tree) { gint offset = 0; proto_item *ti = NULL; proto_tree *foo_tree = NULL; ti = proto_tree_add_item(tree, proto_foo, tvb, 0, -1, FALSE); foo_tree = proto_item_add_subtree(ti, ett_foo); proto_tree_add_item(foo_tree, hf_foo_hdr_version, tvb, offset, 1, FALSE); offset += 1; proto_tree_add_item(foo_tree, hf_foo_hdr_type, tvb, offset, 1, FALSE); offset += 1; proto_tree_add_item(foo_tree, hf_foo_hdr_flags, tvb, offset, 1, FALSE); offset += 1; proto_tree_add_item(foo_tree, hf_foo_hdr_bool, tvb, offset, 1, FALSE); offset += 1; proto_tree_add_item(foo_tree, hf_foo_pl_len, tvb, offset, 4, TRUE); offset += 4; proto_tree_add_item(foo_tree, hf_foo_payload, tvb, offset, -1, FALSE); } } 

इस प्रकार, हमने अपने आविष्कार किए गए प्रोटोकॉल के सभी बिट्स को डिक्रिप्ट किया।
आप विभिन्न प्रकार के तत्वों को देख सकते हैं जिनका हमने डिक्रिप्शन के दौरान उपयोग किया था: FT_BOOLEAN, FT_STRING और FT_UINT8। और साथ ही, गैर-संख्यात्मक तत्वों के मामले में, BASE_NONE का उपयोग किया गया था।

अब Wireshark हमारे प्रोटोकॉल का एक बहुत अच्छा विचार है। और इस कदम पर कोई भी रोक सकता है अगर इस तरह के विवरण हमेशा पर्याप्त थे। हमारे पास अभी भी झंडे का क्षेत्र है, जिसे थोड़ा-थोड़ा करके मैन्युअल रूप से विस्तारित करना होगा। और यह भी, यदि प्रोटोकॉल का संस्करण अज्ञात है, तो क्या निष्कर्ष पर भरोसा करना संभव है? खैर, और सबसे महत्वपूर्ण बिंदु - यदि पैकेट पेलोड फ़ील्ड के बिना आता है और शून्य के एक pl_len मूल्य के साथ आता है, तो डिसेक्टर एक अपवाद फेंक देगा। तो, प्लगइन को बेहतर बनाने के लिए एक जगह है। चलिए जारी रखते हैं ...

आउटपुट में भागों को जोड़ें

पूर्णता की कोई सीमा नहीं है! तो यह हमारे मामले में है। आइए शुरू किए गए पैकेज के संस्करण और प्रकार को नाम देकर शुरू करें, जो पैकेज को देखते समय हमें बहुत तेज़ी से जानकारी प्राप्त करने की अनुमति देगा। ऐसा करने के लिए, हमें दो सरणियों की आवश्यकता है:

 static const value_string packetversions[] = { { 1, "Version 1" }, { 0, NULL } }; static const value_string packettypes[] = { { 1, "Ping request" }, { 2, "Ping acknowledgment" }, { 3, "Print payload" }, { 0, NULL } }; 

सरणियों में निर्भरता बहुत सरल है - "मूल्य, मूल्य का नाम"। इस प्रकार, जब एक पैकेज को देखते हैं, तो हम पैकेज के नंगे प्रकार की संख्या को नहीं देखेंगे और याद रखें कि इसका क्या मतलब है, लेकिन तुरंत प्रकार का विवरण देखें। इन सरणियों को एक्सेस करने के लिए, हम स्वयं Wireshark द्वारा प्रदान किए गए VALS मैक्रोज़ का उपयोग करेंगे।

  { &hf_foo_hdr_version, { "FOO Header Version", "foo.hdr.version", FT_UINT8, BASE_DEC, VALS(packetversions), 0x0, NULL, HFILL } }, { &hf_foo_hdr_type, { "FOO Header Type", "foo.hdr.type", FT_UINT8, BASE_DEC, VALS(packettypes), 0x0, NULL, HFILL } } 

हमने संस्करण और पैकेज के प्रकार पर फैसला किया। अब हम झंडे का अधिक विस्तार से वर्णन करेंगे।

 #define FOO_FIRST_FLAG 0x01 #define FOO_SECOND_FLAG 0x02 #define FOO_ONEMORE_FLAG 0x04 static int hf_foo_flags_first = -1; static int hf_foo_flags_second = -1; static int hf_foo_flags_onemore = -1; void proto_register_foo(void) { ... { &hf_foo_flags_first, { "FOO first flag", "foo.hdr.flags.first", FT_BOOLEAN, FT_INT8, NULL, FOO_FIRST_FLAG, NULL, HFILL } }, { &hf_foo_flags_second, { "FOO second flag", "foo.hdr.flags.second", FT_BOOLEAN, FT_INT8, NULL, FOO_SECOND_FLAG, NULL, HFILL } }, { &hf_foo_flags_onemore, { "FOO onemore flag", "foo.hdr.flags.onemore", FT_BOOLEAN, FT_INT8, NULL, FOO_ONEMORE_FLAG, NULL, HFILL } } ... } static void dissect_foo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { ... proto_tree_add_item(foo_tree, hf_foo_hdr_flags, tvb, offset, 1, FALSE); proto_tree_add_item(foo_tree, hf_foo_flags_first, tvb, offset, 1, FALSE); proto_tree_add_item(foo_tree, hf_foo_flags_second, tvb, offset, 1, FALSE); proto_tree_add_item(foo_tree, hf_foo_flags_onemore, tvb, offset, 1, FALSE); offset += 1; ... } 

चूंकि ध्वज "1" या "0" मूल्यों के साथ जानकारी का एक सा है, इसलिए हम FT_BOOLEAN प्रकार का उपयोग करते हैं। हमने छठे पैरामीटर (FOO_FIRST_FLAG, FOO_SECOND_FLAG, FOO_ONEMORE_FLAG) के साथ प्रत्येक झंडे के लिए मुखौटा निर्धारित किया है कि बाइट से किस बिट की व्याख्या की जाए। ध्यान दें कि हम सभी झंडे के लिए एक ही ऑफसेट चर का उपयोग करते हैं।

निष्कर्ष अब बहुत अधिक पठनीय है। लेकिन हम नहीं रुकेंगे और इसे और भी जानकारीपूर्ण बना देंगे। नोट: विंडसर पैकेज को "FOO प्रोटोकॉल" के रूप में संदर्भित करता है। हमने प्रोटोकॉल दर्ज करते समय यह नाम निर्धारित किया है। Wireshark इस नाम में अतिरिक्त जानकारी जोड़ने की क्षमता प्रदान करता है। हम इस क्षेत्र में प्रोटोकॉल के प्रकार के बारे में जानकारी प्रदर्शित करते हैं। ऐसा करने के लिए, हमें tvb_get_guint8 () ² का उपयोग करके प्रकार मान प्राप्त करने की आवश्यकता है। परिणामी मूल्य दो स्थानों पर प्रदर्शित किया जाएगा: प्रोटोकॉल नाम के तुरंत बाद और जानकारी कॉलम में।

 static void dissect_foo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { guint8 packet_version = tvb_get_guint8(tvb, 0); guint8 packet_type = tvb_get_guint8(tvb, 1); guint32 packet_pl_len = 0; col_set_str(pinfo->cinfo, COL_PROTOCOL, "FOO"); col_clear(pinfo->cinfo, COL_INFO); if (tree) { gint offset = 0; proto_item *ti = NULL; proto_tree *foo_tree = NULL; ti = proto_tree_add_item(tree, proto_foo, tvb, 0, -1, FALSE); foo_tree = proto_item_add_subtree(ti, ett_foo); proto_tree_add_item(foo_tree, hf_foo_hdr_version, tvb, offset, 1, FALSE); offset += 1; switch ( packet_version ) { case 1: col_add_fstr(pinfo->cinfo, COL_INFO, "Type: %s", val_to_str(packet_type, packettypes, "Unknown (0x%02x)")); proto_item_append_text(ti, ", Type: %s", val_to_str(packet_type, packettypes, "Unknown (0x%02x)")); proto_tree_add_item(foo_tree, hf_foo_hdr_type, tvb, offset, 1, FALSE); offset += 1; proto_tree_add_item(foo_tree, hf_foo_hdr_flags, tvb, offset, 1, FALSE); proto_tree_add_item(foo_tree, hf_foo_flags_first, tvb, offset, 1, FALSE); proto_tree_add_item(foo_tree, hf_foo_flags_second, tvb, offset, 1, FALSE); proto_tree_add_item(foo_tree, hf_foo_flags_onemore, tvb, offset, 1, FALSE); offset += 1; proto_tree_add_item(foo_tree, hf_foo_hdr_bool, tvb, offset, 1, FALSE); offset += 1; proto_tree_add_item(foo_tree, hf_foo_pl_len, tvb, offset, 4, TRUE); packet_pl_len = tvb_get_ntohl(tvb, offset); offset += 4; if ( packet_pl_len ) proto_tree_add_item(foo_tree, hf_foo_payload, tvb, offset, -1, FALSE); break; default: col_add_fstr(pinfo->cinfo, COL_INFO, "Unknown version of Foo protocol (0x%02x)", packet_version); } } } 

हम प्राप्त मानों को मैक्रो val_to_str () में पास करते हैं , जो दिए गए मान के लिए विवरण स्ट्रिंग लौटाता है, या वह स्ट्रिंग जो हमने निर्दिष्ट की है यदि विवरण नहीं मिला है।
जब एक अपवाद फेंका गया था तो हमने अनुचित पेलोड हैंडलिंग के साथ एक त्रुटि भी तय की थी।
और इसके अलावा उन्होंने प्रोटोकॉल के विभिन्न संस्करणों के लिए ब्रांचिंग को जोड़ा।

इसके अलावा

फू प्रोटोकॉल के लिए एक काम कर रहे विच्छेदक का एक उदाहरण

tvb_get_guint8 ()

Tvb_get_guint8 () फ़ंक्शन के अलावा, कई अन्य हैं, जिनमें से एक विवरण फाइल वायरशर्क / ईपन / tvbuff.h में पाया जा सकता है।

पुरालेख

पुरालेख काम कर रहे स्रोत फ़ाइलों के साथ। में शामिल हैं:

• पैकेट- foo.c - विच्छेदन प्लगइन का स्रोत कोड
• CMakeLists.txt - प्लगइन के लिए cmake फ़ाइल
• send-foo-packet.c - फू पैकेट भेजने वाले प्रोग्राम का सोर्स कोड

35000 पोर्ट के लिए एक फू पैकेट भेजने वाले कार्यक्रम की सूची *

 #include <arpa/inet.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <fcntl.h> #define FOO_PORT 35000 #define BUFFER_SIZE 210 struct _message { unsigned char pck_version; // = argv[1] unsigned char pck_type; // = 1 | 3 unsigned char pck_flags; // = rand unsigned char pck_boolean; // = rand unsigned int pck_payload_len; // = strlen(argv[2]) }; int main(int argc, char ** argv) { if ( argc != 3 ) { printf("Usage: %s <version> <ping|\"text\">\n", argv[0]); return 1; } struct sockaddr_in cli_addr; int s, cli_len = sizeof(cli_addr); char buf[BUFFER_SIZE]; struct _message msg; msg.pck_version = atoi(argv[1]); msg.pck_payload_len = 0; unsigned int randomData = open("/dev/urandom", O_RDONLY); unsigned int myRandomInteger; read(randomData, &myRandomInteger, sizeof(myRandomInteger)); msg.pck_flags |= myRandomInteger%8; read(randomData, &myRandomInteger, sizeof(myRandomInteger)); msg.pck_boolean = myRandomInteger%2; close(randomData); if ( (s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1 ) { perror("socket"); exit(1); } memset((char*)&cli_addr, 0, sizeof(cli_addr)); cli_addr.sin_family = AF_INET; cli_addr.sin_port = htons(FOO_PORT); cli_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); memset(buf, 0, BUFFER_SIZE); if ( ! strcmp(argv[2], "ping") ) { msg.pck_type = 1; } else { msg.pck_type = 3; msg.pck_payload_len = (strlen(argv[2])<200)?strlen(argv[2]):200; strncpy(buf+sizeof(struct _message), argv[2], (strlen(argv[2])<200)?strlen(argv[2]):199); } memcpy(buf, (char*)&msg, sizeof(struct _message)); if ( sendto(s, buf, sizeof(struct _message)+msg.pck_payload_len, 0, (struct sockaddr*)&cli_addr, cli_len) == -1 ) { perror("sendto"); exit(1); } exit(0); } 

  * मूर्ख से सुरक्षा के बिना कार्यक्रम