Sniffles--IDS और रेगुलर एक्सप्रेशन मूल्यांकन के लिए पैकेट कैप्चर जनरेटर

Sniffles एक उपकरण है जो पैकेट कैप्चर बनाने के लिए है जो IDS का परीक्षण करेगा जो संदिग्ध व्यवहार का पता लगाने के लिए निश्चित पैटर्न या रेगुलर एक्सप्रेशन का उपयोग करते हैं। Sniffles बहुत सरलता से काम करता है। यह रेगुलर एक्सप्रेशन या नियमों का एक सेट लेता है और बेतरतीब ढंग से एक रेगुलर एक्सप्रेशन या नियम चुनता है। फिर यह उस नियम या रेगुलर एक्सप्रेशन के आधार पर सामग्री उत्पन्न करता है। निश्चित स्ट्रिंग्स के लिए, इसका मतलब है कि स्ट्रिंग को सीधे डेटा में जोड़ना (संभवतः Snort नियमों के अनुसार ऑफसेट या अन्य विकल्पों के साथ)। रेगुलर एक्सप्रेशन के लिए प्रक्रिया कुछ अधिक जटिल है। रेगुलर एक्सप्रेशन को NFA में बदल दिया जाता है और NFA के माध्यम से एक यादृच्छिक पथ चुना जाता है (शुरू से अंत तक)। परिणामी डेटा रेगुलर एक्सप्रेशन से मेल खाएगा। अंत में, Sniffles को पूर्ण मिलान या आंशिक मिलान पर सेट किया जा सकता है। पूर्ण मिलान के साथ, पैकेट डेटा कम से कम एक नियम या रेगुलर एक्सप्रेशन से पूरी तरह मेल खाएगा (हालांकि कुछ Snort विकल्पों पर पूरी तरह से विचार नहीं किया जाता है)। आंशिक मिलान मिलान वर्ण अनुक्रम से अंतिम वर्ण मिटा देगा ताकि एक अनुक्रम बने जो मेल नहीं खाना चाहिए (हालांकि दूसरे नियम से मेल खा सकता है)। मिलान वाले नियमों से IDS पर सबसे अधिक बोझ पड़ना चाहिए। इस प्रकार, यह निर्धारित करना संभव है कि IDS सबसे खराब स्थिति के ट्रैफ़िक को कितनी अच्छी तरह संभालता है। आंशिक मिलान ट्रैफ़िक लगभग उतना ही बोझ डालेगा जितना मिलान ट्रैफ़िक। अंत में, Sniffles पूरी तरह से यादृच्छिक डेटा वाला ट्रैफ़िक भी उत्पन्न कर सकता है। ऐसा यादृच्छिक डेटा सर्वोत्तम स्थिति का परिदृश्य प्रदान करता है क्योंकि यादृच्छिक डेटा के किसी भी नियम से मेल खाने की संभावना बहुत कम होती है। इस प्रकार, इसे अधिकतम गति से संसाधित किया जा सकता है। इस प्रकार, Sniffles IDS डीप पैकेट निरीक्षण के सर्वोत्तम और सबसे खराब स्थिति संचालन के लिए पैकेट कैप्चर बनाने की अनुमति देता है।

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

अंत में, Sniffles यादृच्छिक नेटवर्क ट्रैफ़िक उत्पन्न करने के लिए भी बहुत कुछ कर सकता है। डिफ़ॉल्ट रूप से, यादृच्छिक ट्रैफ़िक TCP, UDP या ICMP होता है और एकदिशीय होता है। हालाँकि, यह प्रत्येक स्ट्रीम के लिए ACK, हैंडशेक और टियरडाउन के साथ TCP ट्रैफ़िक भी उत्पन्न कर सकता है। यह सही अनुक्रम संख्या और चेकसम उत्पन्न करेगा। इसके अलावा, MAC पतों को वांछित वितरण के अनुसार सेट किया जा सकता है, और IP नेटवर्क पतों को होम और एक्सटर्नल पता स्थानों द्वारा परिभाषित किया जा सकता है। इसके अलावा, ट्रैफ़िक कैप्चर के भीतर स्कैन का अनुकरण करना संभव है।

Install

आवश्यकता है: Python 3.3+ और SortedContainers मॉड्यूल

Sniffles में निम्नलिखित फ़ाइलें शामिल हैं:

rulereader.py: नियमों के लिए पार्सर।
ruletrafficgenerator.py: सामग्री स्ट्रीम उत्पन्न करने का उपकरण।
sniffles.py: मुख्य प्रोग्राम जो प्रक्रिया का प्रबंधन करता है।
sniffles_config.py: कमांड लाइन इनपुट और Sniffles के विकल्पों को संभालता है।
traffic_writer.py: एक पैकेट को pcap संगत फ़ाइल में लिखता है। libpcap की आवश्यकता नहीं है।
vendor_mac_list.py: MAC ऑर्गनाइज़ेशनली यूनिक आइडेंटिफ़ायर शामिल हैं जो केवल बेतरतीब ढंग से एकसाथ जोड़े गए ऑक्टेट के बजाय अर्ध-यथार्थवादी MAC पते उत्पन्न करने के लिए उपयोग किए जाते हैं।
examples/vendor_mac_definition.txt: आंशिक या पूर्ण MAC पतों के वितरण को परिभाषित करने के लिए वैकल्पिक फ़ाइल।
pcre फ़ाइलें (pcre_chartables.c pcre_compile.c pcre_globals.c pcre_internal.h pcre_newline.c pcre_tables.c pcre.h pcrecomp.c pcreconf.py ucp.h)।
nfa.py: NFA को ट्रैवर्स करने के लिए।
regex_generator.py: यादृच्छिक रेगुलर एक्सप्रेशन उत्पन्न करने का कोड।
rand_rule_gen.py, feature.py, और rule_formats.py: यादृच्छिक नियम सेट उत्पन्न करने के लिए मॉड्यूल।

स्थापित करने के लिए:

शीर्ष-स्तरीय निर्देशिका पर जाएं।
python3.x setup.py install टाइप करें।
यह एप्लिकेशन को आपके सिस्टम पर स्थापित करेगा।

स्थापना नोट्स:

इसका परीक्षण विंडोज़ पर नहीं किया गया है और न ही Linux पर किया गया है। इसका परीक्षण FreeBSD और Mac OS X पर किया गया है।
स्थानीय रूप से बनाने के लिए python3.x setup.py build का उपयोग करें, फिर लाइब्रेरी निर्देशिका पर जाएं, lib ढूंढें और स्थानीय रूप से चलाने के लिए python3.4 -c "from sniffles import sniffles; sniffles.main()" का उपयोग करें।

समर्थित प्रारूप:

Snort: Snort अलर्ट नियम (नियम Alert निर्देश से शुरू होना चाहिए)। Content टैग को पहचाना और सही ढंग से पार्स किया जाता है। PCRE टैग को भी इसी प्रकार सही ढंग से पार्स किया जाता है। HTTP टैग को क्रमिक रूप से संसाधित किया जाता है ताकि वे वांछित पैकेट न बना सकें। Content (और PCRE या HTTP सामग्री) को distance, within और offset द्वारा संशोधित किया जा सकता है। एक नियम फ्लो कंट्रोल विकल्प का उपयोग कर सकता है, हालांकि इससे केवल डेटा की दिशा प्राप्त होती है। nocase विकल्प को अनदेखा किया जाता है और प्रस्तुत मामले का उपयोग किया जाता है। अन्य सभी विकल्पों को अनदेखा किया जाता है। हेडर मानों को पार्स किया जाता है और उन मानों को पूरा करने वाला एक पैकेट उत्पन्न किया जाएगा। यदि होम और एक्सटर्नल नेटवर्क पता स्थानों का उपयोग किया जाता है तो क्रमशः $HOME_NET और $EXTERNAL_NET चर के लिए सही स्थान का उपयोग किया जाएगा। उदाहरण:

alert tcp $EXTERNAL_NET any -> $HOME_NET 8080 (msg:"SERVER-APACHE Apache Tomcat UNIX platform directory traversal"; flow:to_server; content:"/..|5C|/"; content:"/..|5C|/"; http_raw_uri;
रेगुलर एक्सप्रेशन: एक पंक्ति में 1 रेगुलर एक्सप्रेशन, या तो abc या /abc/i के रूप में लिखा गया। वर्तमान में विकल्प i, s, और m का समर्थन करता है। अन्य विकल्पों को अनदेखा किया जाता है। उदाहरण:

/ab*c(d|e)f/i
Sniffles नियम प्रारूप नीचे वर्णित है।

कमांड लाइन विकल्प:

-a TCP Ack: प्रत्येक डेटा पैकेट भेजने के लिए TCP पावती भेजें। डिफ़ॉल्ट रूप से बंद। पावती पैकेट में डिफ़ॉल्ट रूप से कोई डेटा नहीं होता है।
-b द्विदिशीय डेटा: TCP स्ट्रीम की दोनों दिशाओं में डेटा उत्पन्न किया जाएगा। ACK चालू कर दिए जाएंगे। यह सुविधा डिफ़ॉल्ट रूप से बंद है।
-B [पृष्ठभूमि ट्रैफ़िक प्रोटोकॉल:प्रतिशत]: पृष्ठभूमि ट्रैफ़िक उत्पन्न करने के लिए 1 से 100 के बीच मान वाला कम से कम एक प्रोटोकॉल सेट करें। यह मान कुल ट्रैफ़िक के प्रतिशत का प्रतिनिधित्व करता है। उपलब्ध प्रोटोकॉल: FTP, HTTP, IMAP, POP और SMTP। उदाहरण के लिए: "http:20,ftp:30,smtp:10"। यादृच्छिक रूप से ट्रैफ़िक उत्पन्न करने के लिए तर्क मान के रूप में केवल एक संख्या दर्ज करें। उदाहरण के लिए: "80"।
-c गणना: बनाने के लिए स्ट्रीम की संख्या। प्रत्येक स्ट्रीम में कम से कम 1 पैकेट होगा। पैकेट दो एंड-पॉइंट्स के बीच होगा जैसा कि नियम द्वारा परिभाषित किया गया है या बेतरतीब ढंग से चुना गया है। tcp_handshake, tcp_teardown और packets_per_stream प्रति स्ट्रीम पैकेट की संख्या बढ़ाएंगे। वर्तमान में, एक स्ट्रीम में डेटा केवल एक दिशा में बहता है। यदि -b विकल्प का उपयोग किया जाता है तो डेटा दोनों दिशाओं में प्रवाहित होना चाहिए। साथ ही, Sniffles नियम दोनों दिशाओं में डेटा प्रवाहित करने के लिए नामित कर सकते हैं।
-C समवर्ती प्रवाह: एक समय में खुले रहने वाले प्रवाहों की संख्या। सर्वोत्तम प्रयास; यदि समवर्ती प्रवाहों की निर्दिष्ट संख्या से कम प्रवाह हैं तो सभी वर्तमान प्रवाहों का उपयोग किया जाएगा। उदाहरण के लिए, यदि केवल 1000 प्रवाह शेष हैं, लेकिन समवर्ती प्रवाहों की संख्या 10000 निर्धारित की गई थी, तब भी उस समय केवल 1000 प्रवाह ही लिखे जाएंगे। डिफ़ॉल्ट मान 1000 है। यदि अवधि के साथ उपयोग किया जाता है तो -C प्रवाह पूरी अवधि में बनाए रखा जाएगा जो अंततः -c से किसी भी इनपुट को अनदेखा कर देगा। ध्यान दें, इसका उद्देश्य एक विविध pcap बनाना है जहां एक ही प्रवाह के पैकेट एक दूसरे के बगल में होने के बजाय फैले हुए हों और कई समवर्ती प्रवाहों का भ्रम पैदा करना हो। हमारे परीक्षणों में, हम मेमोरी एक समस्या बनने से पहले 2-3 मिलियन समवर्ती प्रवाहों तक प्रबंधित कर चुके हैं। साथ ही, हमें यह उल्लेख करना चाहिए कि स्ट्रीम के बीच अलग-अलग विलंबता के कारण कुछ प्रवाह दूसरों की तुलना में पहले समाप्त हो सकते हैं।
-d नियम निर्देशिका: नियम फ़ाइलों वाली निर्देशिका का पथ। निर्देशिका में सभी नियम फ़ाइलों में सभी सक्षम नियमों को पढ़ेगा। मानता है कि सभी नियम .rules एक्सटेंशन के साथ समाप्त होते हैं। इस विकल्प या -f का उपयोग करें, लेकिन दोनों का नहीं। # प्रतीक का उपयोग किसी नियम को निष्क्रिय करने (अर्थात टिप्पणी करने) के लिए किया जाता है।
-D अवधि: गणना के बजाय अवधि के आधार पर उत्पन्न करें। अवधि सेकंड में है। ध्यान रखें कि पैकेट के बीच डिफ़ॉल्ट विलंबता औसतन 1-200 माइक्रोसेकंड है। कम विलंबता के लिए, एक बड़ी अवधि के परिणामस्वरूप लाखों पैकेट हो सकते हैं जिन्हें बनाने में लंबा समय लग सकता है। साथ ही, अवधि सर्वोत्तम प्रयास है। मूल रूप से, अवधि पूरी होने के बाद नई स्ट्रीम नहीं बनाई जाती हैं, लेकिन ऐसी स्ट्रीम हो सकती हैं जो पूरी नहीं हुई हैं। ये अभी भी लिखी जाती हैं, इसलिए वास्तविक अवधि निर्दिष्ट अवधि से अधिक लंबी हो सकती है, लेकिन कम नहीं होनी चाहिए। अंत में, यदि आप जनरेशन के दौरान कम स्ट्रीम बनाना चाहते हैं तो एक बड़ी विलंबता सेट करें।

उदाहरण:

नोट: सभी उदाहरण मानते हैं कि आपने sniffles पैकेज स्थापित कर लिया है।

नियमों से मेल खाने वाले प्रत्येक पैकेट के साथ 10 स्ट्रीम वाले एकल रेगुलर एक्सप्रेशन फ़ाइल से pcap उत्पन्न करने के लिए:

sniffles -c 10 -f myre.re -m

एकल Snort नियम फ़ाइल से pcap उत्पन्न करने के लिए जहां प्रत्येक पैकेट लगभग एक नियम से मेल खाता है:

sniffles -c 10 -f myrules.rules

एक एकल निर्देशिका में कई Snort नियम फ़ाइलों से pcap उत्पन्न करने के लिए जहां प्रत्येक पैकेट एक नियम से मेल खाता है:

sniffles -c 10 -d myrulesdir -m

उसी pcap को उत्पन्न करने के लिए, समान नियमों का उपयोग करते हुए, लेकिन यादृच्छिक सामग्री के साथ (सामग्री यादृच्छिक है, हेडर अभी भी नियमों का पालन करेंगे--regex या Sniffles नियमों के साथ काम नहीं करता है):

sniffles -c 10 -d myrulesdir -r

10 स्ट्रीम (प्रत्येक में 1 पैकेट) और यादृच्छिक डेटा के साथ pcap उत्पन्न करने के लिए:

sniffles -c 10

10 स्ट्रीम के साथ pcap उत्पन्न करने के लिए जहां 50% स्ट्रीम पृष्ठभूमि ट्रैफ़िक होंगी और बाकी स्ट्रीम में एक नियम से मेल खाने वाले पैकेट होंगे:

sniffles -c 10 -B 50 myrules.rules

10 स्ट्रीम के साथ pcap उत्पन्न करने के लिए, प्रत्येक स्ट्रीम में 5 पैकेट, ACK और हैंडशेक और टियरडाउन के साथ-साथ प्रत्येक डेटा-युक्त पैकेट में डेटा के लिए 50 की निश्चित लंबाई:

sniffles -c 10 -p 5 -l 50 -t -T -a

20 यादृच्छिक स्ट्रीम के साथ pcap उत्पन्न करने के लिए जिसमें 192.168.1-2.x का होम नेटवर्क हो:

sniffles -c 20 -h 192.168.1,192.168.2

20 यादृच्छिक स्ट्रीम के साथ pcap उत्पन्न करने के लिए जिसमें IPv4 के लिए 192.168.1.x और IPv6 के लिए 2001:8888:8888 का होम नेटवर्क हो और 50% ट्रैफ़िक IPv6 हो:

sniffles -c 20 -h 192.168.1 -H 2001:8888:8888 -i 50

यादृच्छिक पैकेटों का 5 सेकंड का पैकेट कैप्चर उत्पन्न करने के लिए जिसमें पैकेटों के बीच औसत अंतराल 100 माइक्रोसेकंड हो:

sniffles -D 5 -L 100

एक pcap उत्पन्न करने के लिए जो एक नियम फ़ाइल (या regex फ़ाइल) में प्रत्येक नियम से मेल खाने वाला एक पैकेट क्रम में बनाएगा:

sniffles -f myrules.rules -e

एक pcap उत्पन्न करने के लिए जो एक regex के प्रत्येक संभावित शाखा के लिए एक पैकेट बनाएगा, regex सेट में प्रत्येक regex के लिए और फिर उस फ़ाइल को everything.pcap नामक pcap में सहेजेगा, नीचे दिए अनुसार है। हालांकि, यह फ़ंक्शन घातीय समय में चल सकता है यदि regex में बड़ी मात्रा में min-max काउंटिंग है, इसलिए इसे चलने में लंबा समय लग सकता है। इसके अलावा, नीचे चित्रित दो विकल्पों को छोड़कर अन्य सभी विकल्पों को अनदेखा किया जाता है:

sniffles -f myrules.rules -o everything.pcap -E

2 सेकंड में होने वाले और 2 सेकंड तक चलने वाले स्कैन हमले के साथ यादृच्छिक ट्रैफ़िक उत्पन्न करने के लिए, प्रति सेकंड 1000 स्कैन पैकेट, और पूरे कैप्चर की अवधि 5 सेकंड और अंतराल समय 50us और प्रारंभिक पोर्ट 80 (पोर्ट 80 से क्रमिक रूप से खोज) के साथ:

sniffles -D 5 -O 2 -W 2 -I 1000 -L 50 -s 192.168.1.2 -P 80

उपरोक्त के समान, लेकिन कई स्कैन हमले बनाएगा, प्रत्येक की अवधि 1 सेकंड, और हमलों के बीच औसत ऑफसेट 2 सेकंड। इसके अलावा, केवल निर्दिष्ट पोर्ट को स्कैन करता है। साथ ही 192.168.1.0-255 रेंज में IP पते को बेतरतीब ढंग से लक्षित करता है:

sniffles -D 8 -O 2 -W 1 -I 10 -L 50 -s 192.168.1 -P 80,8080,8000,8001

Sniffles नियम प्रारूप:

Sniffles कई नियम प्रारूपों का समर्थन करता है। सबसे पहले, Sniffles Snort नियमों और रेगुलर एक्सप्रेशन (एक प्रति पंक्ति) को पार्स कर सकता है। इसके अलावा, Sniffles का अपना नियम प्रारूप भी है जिसका उपयोग ट्रैफ़िक को स्पष्ट रूप से नियंत्रित करने के लिए किया जा सकता है। यह xml फ़ाइलों के उपयोग के माध्यम से किया जाता है जो ट्रैफ़िक का वर्णन करेंगी। जब इस प्रारूप का उपयोग किया जाता है तो Sniffles के अन्य विकल्प अप्रासंगिक हो सकते हैं। उदाहरण नियम फ़ाइलें examples निर्देशिका में पाई जा सकती हैं। इन नियम फ़ाइलों का उपयोग केवल -f विकल्प के साथ नियम फ़ाइल निर्दिष्ट करके किया जाता है (अर्थात sniffles -f rules.xml)।

Sniffles नियम प्रारूप इस प्रकार है:```xml

<petabi_rules> <traffic_stream proto="tcp" src="any" dst="any" sport="any" dport="any" handshake="True" teardown="True" synch="True" ip="4"> </traffic_stream> <traffic_stream proto="tcp" src="any" dst="any" sport="any" dport="any" handshake="True" teardown="True" synch="True"> </traffic_stream> </petabi_rules>

विस्तार से, टैग इस प्रकार काम करते हैं:

- `<petabi_rules> </petabi_rules>`: यह इस नियम फ़ाइल के सभी नियमों को परिभाषित करता है। केवल इन टैगों का एक सेट होना चाहिए जो सभी निर्दिष्ट ट्रैफ़िक स्ट्रीम को खोलता और बंद करता है।
    - `<rule > </rule>`: एक एकल नियम निर्दिष्ट करता है। एक एकल नियम किसी भी संख्या में ट्रैफ़िक स्ट्रीम या पैकेट उत्पन्न कर सकता है। एक फ़ाइल में कितने भी नियम हो सकते हैं।
        - विकल्प:
            - name: इस नियम का नाम। अधिकतर दस्तावेज़ीकरण के लिए, कोई वास्तविक कार्य नहीं।
        - `<traffic_stream> </traffic_stream>`: एक ट्रैफ़िक स्ट्रीम दो एंडपॉइंट के बीच ट्रैफ़िक को परिभाषित करती है। एक ही ट्रैफ़िक स्ट्रीम के भीतर निर्दिष्ट सभी पैकेट समान एंडपॉइंट साझा करेंगे। किसी दिए गए नियम के लिए कितनी भी ट्रैफ़िक स्ट्रीम निर्दिष्ट की जा सकती हैं। एक ही नियम के भीतर अलग-अलग ट्रैफ़िक स्ट्रीम के अलग-अलग एंडपॉइंट हो सकते हैं या नहीं, जो नीचे दी गई सेटिंग्स पर निर्भर करता है।
            - विकल्प:
                - typets: ट्रैफ़िक स्ट्रीम के प्रकार को निर्दिष्ट करता है जिसका उपयोग हम पैकेट उत्पन्न करने के लिए करेंगे। वर्तमान में, हमारे पास Standard, ScanAttack और BackgroundTraffic हैं।
                - scantype: 1==Syn स्कैन (डिफ़ॉल्ट) 2 == कनेक्शन स्कैन। इसका उपयोग ScanAttack के साथ किया जाता है।
                - target: स्कैन अटैक के लिए लक्ष्य IP पता निर्दिष्ट करें।
                - targetports: स्कैन अटैक के लिए। संभावित पोर्ट की अल्पविराम से अलग की गई सूची, या एक एकल प्रारंभिक पोर्ट प्रदान करें। अन्यथा पोर्ट यादृच्छिक रूप से स्कैन किए जाएंगे। यदि कोई एकल प्रारंभिक पोर्ट प्रदान किया जाता है, तो पोर्ट उस बिंदु से 65535 तक क्रम में स्कैन किए जाएंगे, जिसके बाद वे प्रारंभिक बिंदु पर वापस आ जाएंगे। इस विकल्प का उपयोग typets के 'ScanAttack' होने के साथ किया जाता है।
                - srcport: स्कैन अटैक के लिए स्रोत पोर्ट निर्दिष्ट करें। डिफ़ॉल्ट रूप से यादृच्छिक।
                - duration: स्कैन अटैक की विंडो या अवधि, सेकंड में, यदि typets 'ScanAttack' है।
                - intensity: स्कैन अटैक की तीव्रता यदि typets 'ScanAttack' है।
                - offset: स्कैन अटैक शुरू करने से पहले ऑफ़सेट। ट्रैफ़िक में कई स्कैन सम्मिलित करते समय भी उपयोग किया जाता है।
                - replychance: संभावना कि स्कैन का उत्तर होगा। दूसरे शब्दों में, संभावना कि लक्ष्य पोर्ट खुला है (डिफ़ॉल्ट 20%)। इसका उपयोग ScanAttack के साथ किया जाता है।
                - proto: इस ट्रैफ़िक स्ट्रीम के प्रोटोकॉल को निर्दिष्ट करता है। TCP या UDP या ICMP (परीक्षण नहीं किया गया) होना चाहिए।
                - src: स्रोत IP पता। xxx.xxx.xxx.xxx प्रारूप में एक पता, $EXTERNAL_NET (बाहरी पते के लिए—मानता है कि एक होम नेटवर्क निर्दिष्ट किया गया है), $HOME_NET, या any (यादृच्छिक रूप से IP पता चुनता है) हो सकता है।
                - dst: गंतव्य IP पता। स्रोत IP पते के समान।
                - sport: स्रोत पोर्ट (TCP या UDP मानता है)। Snort पोर्ट फ़ॉर्मेटिंग का उपयोग कर सकता है जो कोष्ठक में अल्पविराम से अलग की गई सूची (जैसे [80,88,89]), एक श्रेणी (जैसे [10:1000]), या any (जैसे 0-65535 से यादृच्छिक चयन) हो सकता है।
                - dport: गंतव्य पोर्ट, sport के अनुसार।
                - handshake: स्ट्रीम की शुरुआत में एक TCP हैंडशेक उत्पन्न करेगा। यदि शामिल नहीं है, तो कोई हैंडशेक नहीं होगा। मान्य मान true या false हैं। डिफ़ॉल्ट false है।
                - latency: पैकेटों के बीच औसत विलंबता (माइक्रोसेकंड में) सेट करें।
                - teardown: जब सभी ट्रैफ़िक भेज दिया जाएगा तब स्ट्रीम को बंद कर देगा, ट्रैफ़िक स्ट्रीम के अंत में TCP teardown जोड़कर। मान्य मान true या false हैं। डिफ़ॉल्ट false है।
                - synch: ट्रैफ़िक स्ट्रीम समकालिक हैं या नहीं। true होने पर, अगली ट्रैफ़िक स्ट्रीम शुरू होने से पहले एक ट्रैफ़िक स्ट्रीम समाप्त होनी चाहिए। false होने पर, सभी सन्निकट स्ट्रीम जो false हैं (यानी अतुल्यकालिक) एक ही समय में निष्पादित होंगी।
                - tcp_overlap: डिफ़ॉल्ट मान false है। true होने पर, दूसरे पैकेट से एक अतिरिक्त सामग्री जोड़ी जाएगी और TCP अनुक्रम संख्या एक से कम कर दी जाएगी ताकि TCP ओवरलैपिंग अनुक्रम संख्या का अनुकरण किया जा सके।
                - ipv: IPv4 या IPv6 निर्दिष्ट करें। मान्य विकल्प 4 या 6 हैं। डिफ़ॉल्ट 4 है।
                - out_of_order: यादृच्छिक रूप से पैकेट क्रम से बाहर आते हैं। ध्यान दें, यह केवल उन पैकेटों के साथ काम करता है जो 'times' विकल्प का उपयोग करते हैं। इसके अलावा, इस विकल्प का उपयोग ack के साथ भी किया जाना चाहिए ताकि ट्रैफ़िक ट्रेस में उचित डुप्लिकेट ack दिखाई दें। मान्य मान true या false हैं। डिफ़ॉल्ट false है।
                - out_of_order_prob: पैकेटों के क्रम से बाहर आने की संभावना सेट करें। उदाहरण के लिए, 10 का मतलब होगा कि प्रत्येक पैकेट के क्रम से बाहर आने की 10% संभावना है। क्रम से बाहर के पैकेट सभी क्रम में पैकेटों के बाद आते हैं। इसके अलावा, वे यादृच्छिक रूप से मिश्रित भी होते हैं। इस प्रकार, यदि 10 पैकेटों में से पहले पैकेट 2 और 5 क्रम से बाहर निर्धारित किए जाते हैं, तो वे 10 पैकेटों में से अंतिम (स्लॉट 9 और 10) आएंगे और मनमाने क्रम में होंगे (यानी 5, 2 से पहले आ सकता है या इसके विपरीत)। इसका मान 1 और 99 के बीच होना चाहिए। डिफ़ॉल्ट 50 है।
                - packet_loss: यादृच्छिक रूप से पैकेट ड्रॉप होते हैं (यानी नहीं आते)। यह केवल 'times' विकल्प के साथ काम करता है। इसके अलावा, इस विकल्प का उपयोग ack विकल्प को true सेट करके भी किया जाना चाहिए ताकि ट्रैफ़िक ट्रेस में डुप्लिकेट ack दिखाई दें। मान्य मान 1 से 99 हैं जो पैकेट के ड्रॉप होने की संभावना दर्शाते हैं। ध्यान दें, पैकेट ड्रॉप केवल डेटा-वाहक पैकेटों पर होता है, ack पर नहीं।
                - ack: इस फ़्लो में प्रत्येक डेटा पैकेट के बाद सर्वर से एक ACK आएगा। मान्य मान true या false हैं। डिफ़ॉल्ट false है।
                - percentage: यह केवल BackgroundTraffic पर लागू होता है और नियम फ़ाइल या निर्देशिका में BackgroundTraffic का केवल एक नियम होना चाहिए। प्रतिशत कुल ट्रैफ़िक स्ट्रीम में बनाए जाने वाले बैकग्राउंड ट्रैफ़िक स्ट्रीम के प्रतिशत को इंगित करता है।
                - http: बैकग्राउंड ट्रैफ़िक स्ट्रीम में http एप्लिकेशन प्रोटोकॉल का प्रतिशत वितरण।
                - ftp: बैकग्राउंड ट्रैफ़िक स्ट्रीम में ftp एप्लिकेशन प्रोटोकॉल का प्रतिशत वितरण।
                - pop: बैकग्राउंड ट्रैफ़िक स्ट्रीम में pop एप्लिकेशन प्रोटोकॉल का प्रतिशत वितरण।
                - smtp: बैकग्राउंड ट्रैफ़िक स्ट्रीम में smtp एप्लिकेशन प्रोटोकॉल का प्रतिशत वितरण।
                - imap: बैकग्राउंड ट्रैफ़िक स्ट्रीम में imap एप्लिकेशन प्रोटोकॉल का प्रतिशत वितरण।
            - `<pkt > </pkt>`: यह निर्देश एक व्यक्तिगत पैकेट या पैकेटों की एक श्रृंखला निर्दिष्ट करता है। times सुविधा का उपयोग एक <pkt> </pkt> निर्देश को कई पैकेट उत्पन्न करने के लिए किया जा सकता है। अन्यथा, प्रत्येक दिशा में प्रत्येक पैकेट को स्पष्ट रूप से निर्दिष्ट करना आवश्यक है।
                - विकल्प:
                    - dir: पैकेट की दिशा। मान्य मान to server या to client हैं। प्रारंभिक src IP को क्लाइंट माना जाता है, और प्रारंभिक dst IP को सर्वर माना जाता है। इस प्रकार 'to server' क्लाइंट से सर्वर पर एक पैकेट भेजता है और 'to client' सर्वर से क्लाइंट पर एक पैकेट भेजता है। डिफ़ॉल्ट to server है।
                    - content: इस पैकेट के लिए सामग्री को निर्दिष्ट करने वाला रेगुलर एक्सप्रेशन। पैकेट का आकार रेगुलर एक्सप्रेशन पर निर्भर करेगा।
                    - fragment: इस पैकेट को खंडित करना है या नहीं। केवल ipv4 के साथ काम करता है। मान 2 से बड़ा होना चाहिए। जितने खंड मान्य हैं या जितने निर्दिष्ट हैं (जो भी छोटा हो) उतने खंड बनाएगा। डिफ़ॉल्ट मान 0 है जिसका अर्थ है कोई खंड नहीं।
                    - ack: इस पैकेट को ack भेजना है या नहीं। मान्य मान true या false हैं। डिफ़ॉल्ट false है।
                    - split: सामग्री को निर्दिष्ट संख्या में पैकेटों में विभाजित करें। डिफ़ॉल्ट रूप से सभी सामग्री एक एकल पैकेट में भेजी जाती है (खंड इस नियम के छोटे अपवाद हैं)।
                    - times: इस पैकेट को x बार भेजें। डिफ़ॉल्ट मान 1 है, एक सकारात्मक मान बिल्कुल x पैकेट भेजेगा (संभवतः ack के साथ यदि ack true है), जबकि एक ऋणात्मक संख्या 1 और abs(-x) के बीच यादृच्छिक संख्या में पैकेट भेजेगी।
                    - ttl: पैकेट के लिए टाइम टू लिव मान सेट करें। डिफ़ॉल्ट रूप से, sniffles यादृच्छिक TTL मान उत्पन्न करेगा।
                    - ttl_expiry: पैकेटों को दो अच्छे पैकेटों के बीच एक दुर्भावनापूर्ण पैकेट के साथ कई पैकेटों में तोड़कर ttl expiry हमले का अनुकरण करें। डिफ़ॉल्ट रूप से, मान 0 है (कोई दुर्भावनापूर्ण पैकेट नहीं)। यदि मान अशून्य है, तो यह ttl_expiry मान के बराबर ttl वाला दुर्भावनापूर्ण पैकेट सम्मिलित करेगा। यदि ttl मान सेट है, तो अच्छे पैकेट नए ttl मान के साथ सेट किए जाएंगे।

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

क्रेडिट:
--------

यह एप्लिकेशन Petabi, Inc. द्वारा आपके लिए लाया गया है, जहां हम विश्वसनीय, यथार्थवादी और तीव्र सुरक्षा समाधान बनाते हैं।

लेखक:

- Victor C. Valgenti
- Min Sik Kim
- Tu Le
- Moosuk Pyun

नई सुविधाएं:
-------------

- 11/21/2014: संस्करण 1.4.0 ट्रैफ़िक विभाजन और द्वि-दिशात्मक ट्रैफ़िक जनरेशन के लिए ट्रैफ़ोबोट जोड़ा गया। एक बग ठीक किया गया जहां एक अपवाद फेंका गया था जब उत्पन्न ट्रैफ़िक की मात्रा एक एकल ट्रैफ़िक राइट कॉल में फिट हो सकती थी। उपयोग को सुधारा और सक्षम किया गया। अंत में, ट्रैफ़ोबोट और XML पार्सिंग के लिए यूनिट टेस्ट जोड़े गए।

- 02/03/2015: संस्करण 2.0. विशेष नियमों का उपयोग करके बड़ी स्ट्रीम उत्पन्न करते समय मेमोरी आवश्यकताओं को कम करने के लिए स्ट्रीम के काम करने के तरीके को पूरी तरह से फिर से लिखा गया। वर्तमान में, चीजें धीमी होने से पहले लगभग 2-3 मिलियन समवर्ती फ़्लो को संभाल सकता है। मैंने बड़ी फ़्लो बनाते समय मदद करने के लिए कुछ सुविधाएं जोड़ी हैं। पहले, लगभग 2-3 मिलियन फ़्लो की समवर्तीता के साथ उत्पन्न करें। साथ ही, इन फ़्लो के लिए teardown का उपयोग न करें। फ़्लो का एक अंश शुरुआत से लेकर कैप्चर के अंत तक रहेगा जबकि शेष प्रत्येक बैच अवधि में बंद कर दिए जाएंगे। मैं इसे और कुशल बनाने पर काम करूंगा, लेकिन Sniffles में सभी जटिल विकल्पों का प्रबंधन अब मेमोरी में सस्ते में नहीं किया जा सकता। एकमात्र अन्य समाधान अधिक RAM वाला अधिक शक्तिशाली मशीन प्राप्त करना है। इस संस्करण में विभिन्न सुधार भी शामिल हैं।

- 02/11/2015: आउट-ऑफ-ऑर्डर पैकेटों की आवृत्ति को ट्यून करने की अनुमति देने के लिए आउट-ऑफ-ऑर्डर पैकेटों में संभावना जोड़ी गई।

- 03/05/2015: TCP teardown को मानक teardown अनुक्रम में बदल दिया गया। अब खंडों का उपयोग किए बिना सामग्री को कई पैकेटों में फैलाने की अनुमति है।

- 04/09/2015: स्कैन ट्रैफ़िक ठीक किया गया, यह पिछले परिवर्तनों में से एक के दौरान आंशिक रूप से टूट गया था। pcap प्रारंभिक टाइमस्टैम्प अब डिफ़ॉल्ट रूप से वर्तमान समय है और इसे -g विकल्प के साथ सेट किया जा सकता है। अंत में, तीन-तरफ़ा TCP हैंडशेक में तीसरा पैकेट अब डेटा-वाहक होगा यदि क्लाइंट पहले डेटा भेजने वाला है।

- 05/22/2015: नियम-पार्सिंग को फिर से लिखा गया ताकि अधिक प्रारूपों को समायोजित करने के लिए नियम पार्सर का विस्तार करने की क्षमता को सरल बनाया जा सके। nfa ट्रैवर्सल और pcre को सीधे sniffles में एम्बेड किया गया। कोड को साफ किया गया और इसे सार्वजनिक करने के लिए तैयार किया गया।

- 05/27/2015: दस्तावेज़ीकरण अपडेट किया गया, pcre लाइब्रेरी और nfa निर्माण को sniffles में मर्ज किया गया ताकि इसे एक स्व-निहित पैकेज बनाया जा सके। Sniffles पैकेज के भाग के रूप में Regex Generator और Random Rule Generator जोड़े गए। संस्करण 3.0.0 अपडेट किया गया और github पर प्रकाशित किया गया।

- 08/12/2015: बड़ी संख्या में बग फिक्स और नई सुविधाओं को लागू किया गया। बेहतर एक्सटेंसिबिलिटी की अनुमति देने के लिए स्ट्रीम और फ़्लो को संभालने के तरीके को मौलिक रूप से बदल दिया गया। प्रति फ़्लो विलंबता जोड़ी गई। दस्तावेज़ीकरण अपडेट किया गया।

रेगुलर एक्सप्रेशन जनरेटर
============================

यह एक सरल रेगुलर एक्सप्रेशन जनरेटर है।
यह या तो पूरी तरह से यादृच्छिक रूप से, या वितरणों की एक श्रृंखला के आधार पर रेगुलर एक्सप्रेशन बनाता है।
रेगुलर एक्सप्रेशन उत्पन्न करने के तरीके पर नियंत्रण संरचनात्मक हैं, प्रासंगिक नहीं। दूसरे शब्दों में, उत्पन्न रेगुलर एक्सप्रेशन में कुछ स्ट्रिंग टोकन दिखाने का कोई प्रयास नहीं है। हालांकि, नियमों में पाए जाने वाली सुविधाओं के प्रकारों को प्रभावित करने के लिए संभाव्यता वितरण को समायोजित किया जा सकता है जैसे कैरेक्टर क्लास, विकल्प, पुनरावृत्ति, आदि।

इंस्टॉल
-------

Sniffles के शेष भाग के साथ स्वचालित रूप से इंस्टॉल हो जाएगा।

विकल्प
-------

regexgen--रैंडम रेगुलर एक्सप्रेशन जनरेटर।

    उपयोग: regexgen [-C char distribution] [-c number regex]
    [-D class distribution] [-f output re file]
    [-l lambda for length generation] [-M maximum regex length]
    [-m minimum regex length] [-n negation probability]
    [-o options chance] [-R repetition chance] [-r repetition distribution]
    [-t re structural type distribution] [-?] [-g]

-    -C कैरेक्टर वितरण: यह विशेष वर्णों या वर्ण प्रकारों को देखने की संभावना निर्धारित करता है। इसका उपयोग कैसे करें, इसके उदाहरणों के लिए नीचे वितरण का संक्षिप्त स्पष्टीकरण देखें। डिफ़ॉल्ट रूप से यह वितरण एक समान वितरण है। इस वितरण में पांच स्लॉट हैं: ASCII वर्ण, \x00 प्रारूप में बाइनरी वर्ण, वर्णमाला के अक्षर (ऊपरी या निचला केस), अंक, और प्रतिस्थापन वर्ग (जैसे \w)। इसका एक उदाहरण इनपुट "10,20,10,40,20" होगा जिसका अर्थ होगा कि किसी भी उत्पन्न वर्ण के 10% ASCII, 20% बाइनरी, 10% अक्षर, आदि से आने की 10% संभावना। एक चेतावनी यह है कि ASCII वर्ण जो रेगुलर एक्सप्रेशन के साथ समस्या पैदा कर सकते हैं (जैसे `[` या `{`) को हेक्स प्रतिनिधित्व (\x3b उदाहरण के लिए) में बदल दिया जाता है।
-    -c उत्पन्न करने के लिए रेगुलर एक्सप्रेशन की संख्या। डिफ़ॉल्ट एक है।
-    -D क्लास वितरण: क्लास वितरण में केवल दो स्लॉट हैं। पहला स्लॉट संभावना है कि क्लास यादृच्छिक रूप से उत्पन्न वर्णों की कुछ संख्या से बनी है। दूसरा स्लॉट संभावना है कि क्लास श्रेणियों (जैसे a-z) से बनी है।
-    -f आउटपुट फ़ाइल नाम। यह फ़ाइल का नाम निर्धारित करता है जहां रेगुलर एक्सप्रेशन संग्रहीत होते हैं। डिफ़ॉल्ट वर्तमान कार्यशील निर्देशिका में rand.re नामक फ़ाइल है।
-    -g समूह: सभी रेगुलर एक्सप्रेशन में कम से कम एक या अधिक अन्य रेगुलर एक्सप्रेशन के साथ एक सामान्य उपसर्ग होगा (जब तक कि एक से अधिक रेगुलर एक्सप्रेशन हों।) एक सामान्य उपसर्ग केवल एक रेगुलर एक्सप्रेशन है जो रेगुलर एक्सप्रेशन के कुछ सेट के लिए समान है। संभावित सामान्य उपसर्गों की कुल संख्या 1 से उत्पन्न करने के लिए कुल रेगुलर एक्सप्रेशन के आकार के 1/2 तक है। इस विकल्प का डिफ़ॉल्ट मान false है। यह विकल्प कोई पैरामीटर नहीं लेता है।
-    -l लंबाई के लिए लैम्ब्डा: यह रेगुलर एक्सप्रेशन लंबाई के घातांकीय वितरण के लिए माध्य लंबाई है। डिफ़ॉल्ट मान 10 है।
-    -M अधिकतम रेगुलर एक्सप्रेशन लंबाई: रेगुलर एक्सप्रेशन को अधिकतम इस संरचनात्मक लंबाई या उससे छोटा बनाएं। डिफ़ॉल्ट रूप से, अधिकतम लंबाई सीमित नहीं है।
-    -m न्यूनतम रेगुलर एक्सप्रेशन लंबाई: रेगुलर एक्सप्रेशन को कम से कम इस लंबाई या उससे अधिक बनाएं। डिफ़ॉल्ट 3 है, और यदि इनपुट शून्य या उससे कम है तो स्वचालित रूप से 1 का मान उपयोग करेगा।
-    -n निषेध संभावना: संभावना है कि एक कैरेक्टर क्लास एक निषेध वर्ग ([^xyz]) होगा, न कि एक सामान्य कैरेक्टर क्लास ([xyz])। डिफ़ॉल्ट संभावना 50% है।
-    -o विकल्प संभावना: यह रेगुलर एक्सप्रेशन में एक विकल्प जोड़े जाने की संभावना है। वर्तमान विकल्प 'i', 'm', और 's' हैं। सूची में विकल्पों की एक यादृच्छिक संख्या जोड़ी जाती है, उन विकल्पों को एक समान वितरण के माध्यम से चुना जाता है।
-    -R पुनरावृत्ति संभावना: रेगुलर एक्सप्रेशन में कोई भी संरचनात्मक घटक जोड़े जाने के बाद पुनरावृत्ति होने की संभावना।
-    -r पुनरावृत्ति वितरण: पुनरावृत्ति संरचनाओं का वितरण। स्लॉट हैं: शून्य से एक (?), शून्य से अनेक (*), एक से अनेक (+), और गणना ({x,y})।
-    -t Re संरचनात्मक प्रकार वितरण: रेगुलर एक्सप्रेशन के प्राथमिक संरचनात्मक घटकों का वितरण। इनमें तीन स्लॉट, या श्रेणियां शामिल हैं: वर्ण, वर्ग, और विकल्प। ध्यान दें, विकल्प बस रेगुलर एक्सप्रेशन के शेष लंबाई तक का एक छोटा रेगुलर एक्सप्रेशन उत्पन्न करेगा। दूसरे शब्दों में, विकल्प के परिणामस्वरूप कई छोटे रेगुलर एक्सप्रेशन समग्र रेगुलर एक्सप्रेशन में शामिल हो जाएंगे। विकल्प उन छोटे रेगुलर एक्सप्रेशन को बनाने में बिल्कुल उसी पद्धति का उपयोग करता है।
-   -? यह सहायता प्रिंट करें।

    यह जनरेटर यादृच्छिक रेगुलर एक्सप्रेशन बनाएगा। रेगुलर एक्सप्रेशन के भीतर संरचनाओं को संभाव्यता वितरण में ट्यून करना संभव है, लेकिन वर्तमान में सामग्री को नहीं। यह संभावित रेगुलर एक्सप्रेशन में अधिकतम विविधता का पता लगाने के लिए वांछनीय है (हालांकि जरूरी नहीं कि यथार्थवादी रेगुलर एक्सप्रेशन हों)।
    वितरणों को किसी विशेष वितरण के लिए विभिन्न संभावनाओं या स्लॉट की सूची बनाकर संभाला जाता है। इन्हें कमांड लाइन तर्कों के रूप में एक सरल स्ट्रिंग सूची का उपयोग करके जोड़ा जाता है जैसे: "10,30,40,20"। सूची में उतने ही मान होने चाहिए जितने स्लॉट हैं। सूची में सभी मानों का योग 100 होना चाहिए और कोई भिन्न नहीं होनी चाहिए। प्रत्येक स्लॉट पर मान उस स्लॉट के चुने जाने की संभावना है। उदाहरण के लिए, आधार RE संरचनात्मक प्रकार वितरण में तीन स्लॉट हैं। पहला स्लॉट संभावना है कि अगला संरचना प्रकार एक वर्ण है (जहां एक वर्ण एक अक्षर, अंक, बाइनरी, ASCII, या प्रतिस्थापन वर्ग (जैसे \w) हो सकता है)। दूसरा स्लॉट कैरेक्टर क्लास के लिए है जैसे [ab@%], [^123], या [a-z]। अंतिम स्लॉट विकल्प होने की संभावना है जैसे (ab|cd)। इन तीन स्लॉटों के साथ आप ट्यून कर सकते हैं कि आप अपने रेगुलर एक्सप्रेशन में संरचनाओं को कितनी बार दिखाना चाहते हैं। उदाहरण के लिए, regexgen -c 10 -t "80,10,10" 10 रेगुलर एक्सप्रेशन बनाएगा जहां 80% उपयोग की जाने वाली संरचनाएं वर्ण होंगी, 10% कैरेक्टर क्लास होंगी, और 10% विकल्प होंगी।

रैंडम रूल जनरेटर
=====================

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

इंस्टॉल
-------

Sniffles के साथ स्वचालित रूप से इंस्टॉल होता है

नोट: रैंडम रूल जनरेटर किसी भी प्रकार की सामग्री बनाने के लिए Random Regex Generator का उपयोग करता है।विकल्प
-------

यादृच्छिक नियम जनरेटर

उपयोग: rulegen -c [नियमों की संख्या] -f [फीचर सेट]
        -o [आउटपुट फ़ाइल] [-s]

- -c  नियमों की संख्या: उत्पन्न करने के लिए नियमों की संख्या।
      डिफ़ॉल्ट एक है।
- -f  फीचर सेट: वह फ़ाइल जिसमें फीचर सेट का विवरण है।
      कृपया फीचर सेट और उनका वर्णन करने के तरीके की आगे की व्याख्या के लिए दस्तावेज़ देखें।
- -o  आउटपुट फ़ाइल: वह आउटपुट फ़ाइल जिसमें नियम लिखे जाते हैं।
      डिफ़ॉल्ट rules.txt है।
- -s  Snort नियम प्रारूप: नियमों को Snort नियम प्रारूप में लिखें।
      कोई पैरामीटर नहीं, डिफ़ॉल्ट बंद है।  जब बंद होता है, तो नियम केवल
      स्ट्रिंग प्रारूप में परिवर्तित हो जाते हैं, जो भी फीचर पार्सर पर
      आधारित हो।

फीचर सेट
-----------

फीचर का उपयोग IDS में उपयोग किए जाने वाले नियमों के संभावित पहलुओं का वर्णन करने के लिए किया जाता है।  उदाहरण के लिए, एक पैकेट फ़िल्टर ऐसे नियमों का उपयोग कर सकता है जो IP स्रोत और गंतव्य पते को लक्षित करते हैं।  उस स्थिति में, एक फीचर सेट बनाना संभव होगा जो यह वर्णन करता है कि उन IP स्रोत और गंतव्य पतों को कैसे उत्पन्न किया जाना चाहिए।  अधिक विशेष रूप से, हम सरल नियमों और जटिल नियमों के बीच अंतर करते हैं।  इन दोनों के बीच का अंतर अस्पष्ट संकेतन की उपस्थिति है।  उदाहरण के लिए, यदि हमारे पास किसी भी IP पते को दर्शाने के लिए * का एक अस्पष्ट संकेतन होता, तो हम कह सकते हैं कि * एक अस्पष्ट संकेतन का प्रतिनिधित्व करता है।  इसके अलावा, हम जानते हैं कि एक नियम एक गैर-अस्पष्ट संकेतन का भी उपयोग कर सकता है, जैसे 192.168.1.1।  यह एक सरल IP पते का प्रतिनिधित्व करेगा क्योंकि यह बिना किसी संभावित अस्पष्ट संकेतन के एक एकल निश्चित IP पता है।  फिर हम विशेष फीचर की सीमा को परिभाषित करते हैं (अर्थात संपूर्ण 4 बिलियन से अधिक संभावित IPv4 पतों पर IP पते, या उसका केवल कुछ उपसमूह)।

फीचर अंततः एक मनमाने नियम के सभी पहलुओं को परिभाषित करते हैं।  एक फीचर सेट और एक मान्य नियम प्रारूप दिए जाने पर, उन फीचर का उपयोग करने वाले नियमों की एक मनमानी संख्या को यादृच्छिक रूप से उत्पन्न करना संभव हो जाता है।  इस प्रकार, परीक्षण नियम सेट उत्पन्न करना संभव है जो IDS की जांच एक ऐसे वेक्टर पर करेंगे जो अक्सर छूट जाता है।

फीचर को अर्धविराम से अलग की गई सूची में परिभाषित किया जाता है, प्रति पंक्ति एक फीचर
type=feature; key=value जोड़ों में तर्कों की सूची, python फ़ॉर्मेटिंग का उपयोग करते हुए सूचियाँ (जैसे [a, ..., z])।  फीचर लक्ष्य नियम प्रारूप के विशिष्ट भागों को परिभाषित करते हैं।  फीचर को अधिक कार्यक्षमता जोड़ने के लिए विस्तारित किया जा सकता है।  वैकल्पिक रूप से, कोई नए नियम प्रारूप बनाकर फीचर की क्षमता बढ़ा सकता है।

वर्तमान फीचर प्रकार:

1. फीचर -- सामान्य फीचर
2. सामग्री -- सामग्री फीचर
3. IP -- IP फीचर
4. प्रोटोकॉल -- प्रोटोकॉल फीचर

अस्पष्ट सूचियों को [x:y] जैसी सूचियों के रूप में लिखा जाना चाहिए (एक श्रेणी के लिए), [x,y] (एक सूची के लिए), {x1,x2,x3} (एक सेट के लिए) या केवल * (वाइल्डकार्ड या समान एकल विकल्प के लिए)।

उदाहरण के बारे में अस्पष्ट सूची:```
ambiguity_list=[[2:9]]
it will generate [3:4], [5:6], etc (any [x:y] such that
x <= y and x >= 2 and y > x and y <= 9).

ambiguity_list=[[3,20]]
it will generate [3,9,10], [3,4,8,12], etc (any list [x1,x2,x3,..]
such that all values falling between 3 and 20.

ambiguity_list=[{5,6,10}]
it will generate a subset of {5,6,10} such as {5,10}, {5}.

ambiguity_list=[[2:9],[3,20],{5,6,11}]
it will pick one of [2:9], [3,20], and {5,6,11} and
generate a corresponding instance (see above)

फीचर फ़ाइल का उदाहरण:``` type=protocol; name=proto; proto_list=[TCP,UDP,ICMP]; complexity_prob=0;ambiguity_list=None; type=ip; name=sip; version=4; complexity_prob=100;

उपरोक्त दो विशेषताओं को परिभाषित करता है: एक प्रोटोकॉल विशेषता और एक स्रोत IP विशेषता। प्रोटोकॉल का नाम proto है, जो केवल नियम स्वरूपण के लिए महत्वपूर्ण है, और मान्य प्रोटोकॉल हैं: IP, TCP, UDP, और ICMP। IP विशेषता को IPv4 के रूप में परिभाषित किया गया है और सभी नियम जटिल होंगे। IP जटिलता पहले से ही वर्ग का हिस्सा है और इसे विशेषता परिभाषा में जोड़ने की आवश्यकता नहीं है। यह CIDR संकेतन का उपयोग करके IP पते बनाएगा।

सामान्य विशेषता गुण:

- Feature_name: सूचनात्मक गुण, नियम स्वरूपण के लिए संभावित रूप से मूल्यवान।
- lower_bound: संभावित मानों की निचली सीमा। मानता है कि विशेषता एक संख्या है।
- upper_bound: lower_bound के विपरीत।
- complexity_prob: नियम के लिए जटिल विशेषताओं का उपयोग करने की संभावना। 0 से 100 तक। डिफ़ॉल्ट 0 है।
                   जब जटिल विशेषताओं का उपयोग किया जाता है, तो एक अस्पष्ट संकेतन यादृच्छिक रूप से अस्पष्टता सूची से चुना जाता है, या
                   यदि विशेषता एक विशिष्ट अस्पष्टता परिभाषित करती है (जैसे IP पते) तो उसका उपयोग किया जाता है। जब जटिल
                   विशेषताओं का उपयोग नहीं किया जाता है, तो सीमाओं का उपयोग करके एक मान उत्पन्न किया जाता है, या Content के मामले में,
                   वितरण मानों के एक सेट का उपयोग करके जो उत्पन्न स्ट्रिंग को ASCII वर्णों की एक श्रृंखला
                   तक सीमित करेगा।
- ambiguity_list: संभावित अस्पष्ट संकेतनों की एक सूची।
                  पायथन फ़ॉर्मेटिंग का उपयोग करके अल्पविराम से अलग की गई सूची
                  (जैसे [a, b, c])।
- toString(): इस विशेष विशेषता सेट को देखते हुए एक नियम का उदाहरण प्रिंट करता है।

Content विशेषता -- Feature से विरासत प्राप्त करती है:
- regex: True या False।  यदि True है, तो regex के लिए pcre फ़ॉर्मेटिंग का
         उपयोग करेगा और साथ ही संभवतः regex में विकल्प i, s, या
         m जोड़ेगा।
- length: उत्पन्न सामग्री की औसत लंबाई को परिभाषित करता है।
-  min_regex_length: regex की न्यूनतम लंबाई को परिभाषित करता है।

प्रोटोकॉल विशेषता -- Feature से विरासत प्राप्त करती है:
- proto_list: संभावित प्रोटोकॉल की सूची को परिभाषित करता है,
                 अल्पविराम से अलग की गई सूची के रूप में (जैसे [TCP,
                 UDP])।

IP विशेषता -- Feature से विरासत प्राप्त करती है:
- version: IP संस्करण 4 के लिए 4, IP संस्करण 6 के लिए 6।
           डिफ़ॉल्ट संस्करण 4 है।

रेंज, सूची, सेट के लिए अस्पष्ट संकेतन:

रेंज संकेतन:
  [x:y]  का अर्थ x से y तक (सम्मिलित) है।

सूची संकेतन:
  [x,y] का अर्थ यादृच्छिक रूप से निर्धारित संख्या में मानों की सूची है,
  जहाँ प्रत्येक मान x से बड़ा या उसके बराबर
  और y से छोटा या उसके बराबर है।

सेट संकेतन:
  {x1,x2,x3,x4} का अर्थ मानों x1, x2, x3, x4 का एक सेट है।  यह
  मूल सेट का एक उप-सेट उत्पन्न करेगा।

कृपया अधिक उदाहरणों के लिए example_features फ़ोल्डर में उदाहरण विशेषता सेट देखें।
इसके पीछे अधिक विवरण और शैक्षणिक सिद्धांत को बाद में जोड़े जाने की योजना है।

sniffles