iphelix/packPACK (पासवर्ड विश्लेषण और क्रैकिंग किट)
PACK (पासवर्ड विश्लेषण और क्रैकिंग टूलकिट) उपयोगिताओं का एक संग्रह है जो पासवर्ड सूचियों के विश्लेषण में सहायता के लिए विकसित किया गया है, ताकि मास्क, नियमों, कैरेक्टर-सेट और अन्य पासवर्ड विशेषताओं का पैटर्न पता लगाकर पासवर्ड क्रैकिंग को बढ़ाया जा सके। यह टूलकिट हैशकैट परिवार के पासवर्ड क्रैकर्स के लिए वैध इनपुट फ़ाइलें जनरेट करता है।
नोट: यह टूलकिट स्वयं पासवर्ड क्रैक करने में सक्षम नहीं है, बल्कि पासवर्ड क्रैकर्स के संचालन को अधिक कुशल बनाने के लिए डिज़ाइन किया गया है।
टूलकिट का उपयोग शुरू करने से पहले, हमें पासवर्ड सूचियों के लिए एक चयन मानदंड स्थापित करना होगा। चूँकि हम लोगों द्वारा अपने पासवर्ड बनाने के तरीके का विश्लेषण करना चाहते हैं, हमें लीक हुए पासवर्डों का यथासंभव बड़ा नमूना प्राप्त करना होगा। ऐसी ही एक उत्कृष्ट सूची RockYou.com समझौते पर आधारित है। यह सूची इतना बड़ा और विविध संग्रह प्रदान करती है कि समान साइटों (जैसे सोशल नेटवर्किंग) द्वारा उपयोग किए जाने वाले सामान्य पासवर्डों के लिए अच्छे परिणाम मिलते हैं। इस सूची से प्राप्त विश्लेषण विशिष्ट पासवर्ड नीतियों वाले संगठनों के लिए काम नहीं कर सकता है। इस प्रकार, नमूना इनपुट का चयन आपके लक्ष्य के जितना संभव हो उतना करीब होना चाहिए। इसके अलावा, पहले से क्रैक किए गए पासवर्डों पर आधारित सूचियाँ प्राप्त करने से बचने का प्रयास करें, क्योंकि इससे सूची को क्रैक करने वाले व्यक्ति(यों) द्वारा उपयोग किए गए नियमों और मास्क का सांख्यिकीय पूर्वाग्रह उत्पन्न होगा, न कि वास्तविक उपयोगकर्ताओं का।
सबसे बुनियादी विश्लेषण जो आप कर सकते हैं, वह है प्रदान की गई सूची में पासवर्डों की सबसे सामान्य लंबाई, कैरेक्टर-सेट और अन्य विशेषताओं को प्राप्त करना। नीचे दिए गए उदाहरण में, हम लगभग 14 मिलियन पासवर्डों वाली 'rockyou.txt' का उपयोग करेंगे। निम्नलिखित कमांड लाइन के साथ statsgen.py लॉन्च करें:
$ python statsgen.py rockyou.txt
नीचे उपरोक्त कमांड का आउटपुट है:
_
StatsGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Analyzing passwords in [rockyou.txt]
[+] Analyzing 100% (14344390/14344390) of passwords
NOTE: Statistics below is relative to the number of analyzed passwords, not total number of passwords
[*] Length:
[+] 8: 20% (2966037)
[+] 7: 17% (2506271)
[+] 9: 15% (2191039)
[+] 10: 14% (2013695)
[+] 6: 13% (1947798)
...
[*] Character-set:
[+] loweralphanum: 42% (6074867)
[+] loweralpha: 25% (3726129)
[+] numeric: 16% (2346744)
[+] loweralphaspecialnum: 02% (426353)
[+] upperalphanum: 02% (407431)
...
[*] Password complexity:
[+] digit: min(0) max(255)
[+] lower: min(0) max(255)
[+] upper: min(0) max(187)
[+] special: min(0) max(255)
[*] Simple Masks:
[+] stringdigit: 37% (5339556)
[+] string: 28% (4115314)
[+] digit: 16% (2346744)
[+] digitstring: 04% (663951)
[+] othermask: 04% (576324)
...
[*] Advanced Masks:
[+] ?l?l?l?l?l?l?l?l: 04% (687991)
[+] ?l?l?l?l?l?l: 04% (601152)
[+] ?l?l?l?l?l?l?l: 04% (585013)
[+] ?l?l?l?l?l?l?l?l?l: 03% (516830)
[+] ?d?d?d?d?d?d?d: 03% (487429)
...
नोट: आप --hiderare फ़्लैग शामिल करके आउटलियर्स की संख्या कम कर सकते हैं, जो 1% से कम घटित होने वाली किसी भी वस्तु को नहीं दिखाएगा।
यहां बताया गया है कि हम उपरोक्त सूची से तुरंत क्या सीख सकते हैं:
अंतिम खंड, "Advanced Masks", में हैशकैट प्रारूप का उपयोग करके सबसे अधिक बार आने वाले मास्क शामिल हैं। व्यक्तिगत प्रतीकों की व्याख्या इस प्रकार की जा सकती है:
?l - एक एकल लोअरकेस कैरेक्टर
?u - एक एकल अपरकेस कैरेक्टर
?d - एक एकल अंक
?s - एक एकल विशेष कैरेक्टर
उदाहरण के लिए, सबसे पहला मास्क "?l?l?l?l?l?l?l?l" सभी लोअरकेस अल्फा पासवर्डों से मेल खाएगा। नमूना आकार को देखते हुए, आप लगभग 4% पासवर्ड क्रैक कर पाएंगे। हालांकि, प्रारंभिक आउटपुट जनरेट करने के बाद, आप पासवर्ड डेटा पर ध्यान केंद्रित करने के लिए फ़िल्टर का उपयोग करने में रुचि ले सकते हैं।
आइए देखते हैं कि RockYou उपयोगकर्ता "stringdigit" सरल मास्क (एक स्ट्रिंग के बाद संख्याएँ) का उपयोग करके अपने पासवर्ड कैसे चुनते हैं:
$ python statsgen.py ../PACK-0.0.3/archive/rockyou.txt --simplemask stringdigit -q --hiderare
[*] Analyzing passwords in [rockyou.txt]
[+] Analyzing 37% (5339556/14344390) of passwords
NOTE: Statistics below is relative to the number of analyzed passwords, not total number of passwords
[*] Length:
[+] 8: 23% (1267260)
[+] 7: 18% (981432)
[+] 9: 17% (939971)
[+] 10: 14% (750938)
[+] 6: 11% (618983)
[+] 11: 05% (294869)
[+] 12: 03% (175875)
[+] 13: 01% (103047)
[+] 14: 01% (65958)
[*] Character-set:
[+] loweralphanum: 88% (4720184)
[+] upperalphanum: 06% (325941)
[+] mixedalphanum: 05% (293431)
[*] Password complexity:
[+] digit: min(1) max(252)
[+] lower: min(0) max(46)
[+] upper: min(0) max(31)
[+] special: min(0) max(0)
[*] Simple Masks:
[+] stringdigit: 100% (5339556)
[*] Advanced Masks:
[+] ?l?l?l?l?l?l?d?d: 07% (420318)
[+] ?l?l?l?l?l?d?d: 05% (292306)
[+] ?l?l?l?l?l?l?l?d?d: 05% (273624)
[+] ?l?l?l?l?d?d?d?d: 04% (235360)
[+] ?l?l?l?l?d?d: 04% (215074)
...
आउटपुट के सबसे ऊपर यह निर्दिष्ट किया गया है कि कुल पासवर्डों में से कितने प्रतिशत का विश्लेषण किया गया। इस मामले में, केवल "stringdigit" मास्क से मेल खाने वाले पासवर्डों को क्रैक करके, मूल आउटपुट में दिखाए गए अनुसार कुल सेट का केवल लगभग 37% ही प्राप्त करना संभव है। इसके बाद, ऐसा प्रतीत होता है कि इस पासवर्ड प्रकार के केवल 11% में लोअरकेस के अलावा कुछ और उपयोग होता है। इसलिए इस मास्क से मेल खाने वाले केवल लोअरकेस स्ट्रिंग्स पर ध्यान केंद्रित करना समझदारी होगी। अंत में, "Advanced Mask" अनुभाग में हम देख सकते हैं कि अधिकांश "stringdigit" पासवर्डों में एक स्ट्रिंग के बाद दो या चार अंक होते हैं। उपरोक्त आउटपुट से प्राप्त जानकारी के साथ, हम लक्षित उपयोगकर्ताओं के पासवर्ड जनरेशन पैटर्न की एक मानसिक छवि बनाना शुरू कर सकते हैं।
पासवर्ड की लंबाई, मास्क और कैरेक्टर सेट के लिए कुछ अन्य फ़िल्टर उपलब्ध हैं:
Length: --minlength और/या --maxlength
Simple Mask: --simplemask [numeric, loweralpha, upperalpha, mixedalpha, loweralphanum, आदि.]
Character sets: --charset [digit, string, stringdigit, digitstring, digitstringdigit, आदि.]
नोट: एक ही वर्ग के एक से अधिक फ़िल्टर को अल्पविराम से अलग की गई सूची के रूप में निर्दिष्ट किया जा सकता है:
--simplemask="stringdigit,digitstring"
जबकि "Advanced Mask" अनुभाग केवल 1% से अधिक पासवर्डों से मेल खाने वाले पैटर्न प्रदर्शित करता है, आप निम्नलिखित कमांड का उपयोग करके किसी दिए गए शब्दकोश से मेल खाने वाले पासवर्ड मास्क की पूरी सूची प्राप्त कर सकते हैं और सहेज सकते हैं:
$ python statsgen.py rockyou.txt -o rockyou.masks
सभी पासवर्ड मास्क और उनकी आवृत्तियाँ CSV प्रारूप में निर्दिष्ट फ़ाइल में सहेजी जाएंगी। स्वाभाविक रूप से, आप केवल निर्दिष्ट पैरामीटर से मेल खाने वाले मास्क फ़ाइलें जनरेट करने के लिए फ़िल्टर प्रदान कर सकते हैं। आउटपुट फ़ाइल को अगले भाग में शामिल MaskGen टूल के इनपुट के रूप में उपयोग किया जा सकता है।
MaskGen आपको हैशकैट परिवार के पासवर्ड क्रैकर्स में इनपुट के लिए पैटर्न-आधारित मास्क हमले तैयार करने की अनुमति देता है। यह उपकरण maskgen.py (पिछले खंड में) नामक एक उपयोगिता का उपयोग करता है जो statsgen.py (मास्क उत्पन्न करने के लिए) के आउटपुट को इनपुट के रूप में लेता है। उपकरण maskgen.py (पिछले खंड में) नामक एक उपयोगिता है जो statsgen.py (मास्क उत्पन्न करने के लिए) के आउटपुट को इनपुट के रूप में लेता है। (यह वाक्य संदर्भ में सही नहीं लगता; मूल अंग्रेजी में यह "The tool uses output produced by statsgen above with the '-o' flag" कहता है। इसलिए अनुवाद होगा: "यह उपकरण ऊपर statsgen द्वारा '-o' फ़्लैग के साथ उत्पादित आउटपुट का उपयोग करता है।")
आइए MaskGen को केवल StatGen के आउटपुट के साथ चलाएँ:
$ python maskgen.py rockyou.masks
_
MaskGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Analyzing masks in [rockyou.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Sorting masks by their [optindex].
[*] Finished generating masks:
Masks generated: 146578
Masks coverage: 100% (14344390/14344390)
Masks runtime: >1 year
यहाँ कई जानकारियाँ हैं जिन्हें आपको ध्यान में रखना चाहिए:
चूँकि आपके पास हमलों को करने और तैयार करने के लिए आमतौर पर सीमित समय होता है, maskgen आपको यह निर्दिष्ट करने की अनुमति देता है कि आपके पास मास्क हमले करने के लिए कितना समय है, और यह सॉर्टिंग मोड के आधार पर मास्क का सबसे इष्टतम संग्रह उत्पन्न करेगा। आइए विभिन्न सॉर्टिंग मोड और लक्ष्य समय के साथ थोड़ा खेलें:
$ python maskgen.py rockyou.masks --targettime 600 --optindex -q
[*] Analyzing masks in [rockyou.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Sorting masks by their [optindex].
[!] Target time exceeded.
[*] Finished generating masks:
Masks generated: 779
Masks coverage: 56% (8116195/14344390)
Masks runtime: 0:11:36
$ python maskgen.py rockyou.masks --targettime 600 --complexity -q
[*] Analyzing masks in [rockyou.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Sorting masks by their [complexity].
[!] Target time exceeded.
[*] Finished generating masks:
Masks generated: 5163
Masks coverage: 31% (4572346/14344390)
Masks runtime: 0:10:01
$ python maskgen.py rockyou.masks --targettime 600 --occurrence -q
[*] Analyzing masks in [rockyou.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Sorting masks by their [occurrence].
[!] Target time exceeded.
[*] Finished generating masks:
Masks generated: 4
Masks coverage: 16% (2390986/14344390)
Masks runtime: 1:34:05
उपरोक्त सभी रन का लक्ष्य समय 600 सेकंड (या 10 मिनट) है, जिसमें विभिन्न सॉर्टिंग मोड हैं। हमारे प्रयोगों के आधार पर, OptIndex सॉर्टिंग मोड का उपयोग करके उत्पन्न मास्क लगभग 10 मिनट में RockYou पासवर्डों का 56% क्रैक कर सकते हैं। वहीं, Occurrence सॉर्टिंग मोड का उपयोग करके उत्पन्न मास्क में न केवल केवल 16% का काफी कमजोर कवरेज है, बल्कि वे निर्दिष्ट लक्ष्य समय से एक घंटे से अधिक अधिक भी हैं।
नोट: जटिलता के अनुसार क्रमबद्ध मास्क नीति-आधारित सूचियों पर हमला करते समय बहुत प्रभावी हो सकते हैं।
आइए maskgen द्वारा optindex मोड में उत्पन्न कुछ मास्क को --showmasks फ़्लैग का उपयोग करके देखें:
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q --showmasks
[*] Analyzing masks in [rockyou.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Sorting masks by their [optindex].
[L:] Mask: [ Occ: ] [ Time: ]
...
[ 7] ?l?d?s?l?l?d?d [6 ] [ 0:00:00]
[ 8] ?s?l?l?l?l?l?l?s [3480 ] [ 0:05:36]
[ 9] ?l?l?l?l?d?d?d?d?s [1553 ] [ 0:02:30]
[ 8] ?d?l?d?d?d?l?l?l [47 ] [ 0:00:04]
[ 8] ?d?l?l?d?l?d?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?l?d?d?l?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?d?l?d?d?l?l [47 ] [ 0:00:04]
[ 8] ?d?d?l?l?d?l?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?d?d?l?l?l?l [122 ] [ 0:00:11]
[ 8] ?u?u?d?u?d?d?d?d [18 ] [ 0:00:01]
[ 6] ?d?s?s?s?s?s [4 ] [ 0:00:00]
[10] ?l?l?l?l?l?l?l?l?d?d [213109 ] [ 5:48:02]
[!] Target time exceeded.
[*] Finished generating masks:
Masks generated: 3970
Masks coverage: 74% (10620959/14344390)
Masks runtime: 16:10:38
प्रदर्शित मास्क एक काफी सहज प्रारूप का पालन करते हैं:
[ 9] ?l?l?l?l?d?d?d?d?s [1553 ] [ 0:02:30]
\ \ \
\ _ जनरेट किया गया मास्क \ _ मास्क रनटाइम
\
_ मास्क लंबाई _ मास्क घटना
उपरोक्त नमूने में आप मास्क जनरेशन में जाने वाले कुछ तर्क देख सकते हैं। उदाहरण के लिए, जबकि '?s?l?l?l?l?l?l?s' मास्क का नमूने में सबसे लंबा रनटाइम (5 मिनट) है, फिर भी इसकी तुलनात्मक रूप से उच्च घटना के कारण '?l?l?l?l?d?d?d?d?s' की तुलना में इसकी प्राथमिकता अधिक है। वहीं, जबकि '?l?d?s?l?l?d?d' का कवरेज काफी कम है, फिर भी इसे अन्य मास्कों की तुलना में अधिक प्राथमिकता मिलती है क्योंकि केवल छह अक्षरों का मास्क होने के कारण यह बहुत तेज़ी से निष्पादित होता है।
आप फ़िल्टर का उपयोग करके अपने जनरेट किए गए मास्क हमलों को और अधिक अनुकूलित कर सकते हैं। उदाहरण के लिए, आपके पास पर्याप्त शक्तिशाली हार्डवेयर हो सकता है जहाँ आप 8 अक्षरों तक के सभी पासवर्डों को आसानी से ब्रूटफोर्स कर सकते हैं। इस मामले में, आप --minlength फ़्लैग का उपयोग करके केवल 8 अक्षरों से अधिक के मास्क जनरेट कर सकते हैं:
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q --minlength 8
[*] Analyzing masks in [rockyou.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Sorting masks by their [optindex].
[!] Target time exceeded.
[*] Finished generating masks:
Masks generated: 585
Masks coverage: 41% (5905182/14344390)
Masks runtime: 15:50:36
स्वाभाविक रूप से जनरेट किए गए मास्क कवरेज में कमी आई, लेकिन ये फ़िल्टर तब उपयोगी हो जाते हैं जब उन्हें उत्पन्न करने के लिए उपयोग की गई सूची के अलावा अन्य पासवर्ड सूचियों पर हमला करने के लिए मास्क का संग्रह तैयार किया जाता है।
नीचे सूची अतिरिक्त फ़िल्टर दिखाती है जिनका आप उपयोग कर सकते हैं:
Individual Mask Filter Options:
--minlength=8 न्यूनतम पासवर्ड लंबाई
--maxlength=8 अधिकतम पासवर्ड लंबाई
--mintime=3600 न्यूनतम मास्क रनटाइम (सेकंड)
--maxtime=3600 अधिकतम मास्क रनटाइम (सेकंड)
--mincomplexity=1 न्यूनतम जटिलता
--maxcomplexity=100
अधिकतम जटिलता
--minoccurrence=1 न्यूनतम घटना
--maxoccurrence=100
अधिकतम घटना
Occurrence और complexity फ़्लैग विभिन्न सॉर्टिंग मोड का उपयोग करके जनरेट किए गए मास्क को ठीक करने के लिए विशेष रूप से शक्तिशाली हो सकते हैं।
एक बार जब आप उपरोक्त जनरेट किए गए मास्क से संतुष्ट हो जाते हैं, तो आप उन्हें -o फ़्लैग का उपयोग करके सहेज सकते हैं:
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q -o rockyou.hcmask
[*] Analyzing masks in [rockyou.masks]
[*] Saving generated masks to [rockyou.hcmask]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Sorting masks by their [optindex].
[!] Target time exceeded.
[*] Finished generating masks:
Masks generated: 3970
Masks coverage: 74% (10620959/14344390)
Masks runtime: 16:10:38
यह 'rockyou.hcmask' फ़ाइल उत्पन्न करेगा जिसका उपयोग सीधे Hashcat सूट के टूल या कस्टम स्क्रिप्ट के हिस्से के रूप में किया जा सकता है जो उनमें लूप करती है।
यह देखना अक्सर उपयोगी होता है कि जनरेट किए गए मास्क पहले से क्रैक की गई सूचियों के विरुद्ध कितना अच्छा प्रदर्शन करते हैं। Maskgen एक संग्रह के मास्क की तुलना दूसरों से कर सकता है ताकि यह देखा जा सके कि यदि एक पासवर्ड सूची के मास्क को दूसरे के विरुद्ध प्रयास किया जाए तो वे कितना अच्छा प्रदर्शन करेंगे। आइए देखें कि RockYou सूची से उत्पन्न मास्क Gawker जैसी किसी अन्य समझौता की गई सूची के विरुद्ध कितना अच्छा प्रदर्शन करेंगे:
$ python statsgen.py ../PACK-0.0.3/archive/gawker.dic -o gawker.masks
$ python maskgen.py gawker.masks --checkmasksfile rockyou.hcmask -q
[*] Analyzing masks in [gawker.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Checking coverage of masks in [rockyou.hcmask]
[*] Finished matching masks:
Masks matched: 1775
Masks coverage: 96% (1048889/1084394)
Masks runtime: 16:25:44
'--checkmasksfile' पैरामीटर का उपयोग करके हमने पहले जनरेट किए गए 'rockyou.hcmask' फ़ाइल के अंदर मास्क को नमूना लीक की गई सूची 'gawker.masks' के मास्क के विरुद्ध चलाने का प्रयास किया। इसके परिणामस्वरूप 96% का अच्छा कवरेज मिलता है जहाँ कुल 3970 जनरेट किए गए RockYou-आधारित मास्क में से 1775 Gawker सूची के मास्क से मेल खाते हैं।
एक या अधिक मास्क के कवरेज को सीधे कमांड-लाइन पर निर्दिष्ट करके देखना भी संभव है:
$ python maskgen.py gawker.masks --checkmasks="?u?l?l?l?l?l?d,?l?l?l?l?l?d?d" -q
[*] Analyzing masks in [gawker.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Checking coverage of the these masks [?u?l?l?l?l?l?d, ?l?l?l?l?l?d?d]
[*] Finished matching masks:
Masks matched: 2
Masks coverage: 1% (18144/1084394)
Masks runtime: 0:00:04
निर्दिष्ट दोनों मास्क केवल 1% कवरेज से मेल खाते हैं।
आपके सटीक हार्डवेयर विनिर्देशों और लक्ष्य हैश के आधार पर, आप '--pps' पैरामीटर का उपयोग करके गणना के दौरान उपयोग की जाने वाली कुंजी/सेकंड गति को बढ़ा या घटा सकते हैं:
$ python maskgen.py rockyou.masks --targettime 43200 --pps 50000000 -q
[*] Analyzing masks in [rockyou.masks]
[*] Using 50,000,000 keys/sec for calculations.
[*] Sorting masks by their [optindex].
[!] Target time exceeded.
[*] Finished generating masks:
Masks generated: 1192
Masks coverage: 61% (8754548/14344390)
Masks runtime: 12:17:31
अपने वास्तविक प्रदर्शन से मेल खाने के लिए '--pps' पैरामीटर का उपयोग करने से लक्ष्य समय अधिक सार्थक हो जाता है।
कॉर्पोरेट वातावरण में न्यूनतम पासवर्ड जटिलता आवश्यकताओं के साथ कई मास्क और शब्दकोश हमले विफल हो जाएंगे। शुद्ध ब्रूटफोर्सिंग हमले का सहारा लेने के बजाय, हम पासवर्ड जटिलता नियमों का लाभ उठा सकते हैं ताकि उन पासवर्ड उम्मीदवारों से बचा जा सके जो नीति का अनुपालन नहीं करते हैं, या इसके विपरीत केवल गैर-अनुपालन वाले पासवर्डों का ऑडिट कर सकते हैं। PolicyGen का उपयोग करके, आप पासवर्ड जटिलता का पालन करने वाले मास्क का एक संग्रह उत्पन्न कर पाएंगे ताकि क्रैकिंग के समय में काफी कमी आए।
नीचे एक नमूना सत्र है जहाँ हम एक ऐसे वातावरण के लिए सभी मान्य पासवर्ड मास्क उत्पन्न करते हैं जिसमें कम से कम एक अंक, एक अपरकेस और एक विशेष वर्ण की आवश्यकता होती है।
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o complexity.hcmask
_
PolicyGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected][*] जनरेट किए गए मास्क [complexity.hcmask] में सहेजे जा रहे हैं।
[] गणनाओं के लिए 1,000,000,000 कुंजी/सेकंड का उपयोग किया जा रहा है। [] पासवर्ड नीति: पास लंबाई: min:8 max:8 न्यूनतम शक्ति: l:1 u:1 d:1 s:1 अधिकतम शक्ति: l:None u:None d:None s:None [] [अनुपालन] मास्क जनरेट किए जा रहे हैं। [] 8 अक्षर वाले पासवर्ड मास्क जनरेट किए जा रहे हैं। [] कुल मास्क: 65536 समय: 76 दिन, 18:50:04 [] नीति मास्क: 40824 समय: 35 दिन, 0:33:09
उपरोक्त आउटपुट से आप देख सकते हैं कि हमने निर्दिष्ट जटिलता से मेल खाने वाले 40824 मास्क जनरेट किए हैं, जिन्हें चलाने में 1,000,000,000 कुंजी/सेकंड की गति से लगभग 35 दिन लगेंगे।
यदि आप केवल एक पासवर्ड ऑडिट कर रहे हैं और केवल गैर-अनुपालन पासवर्ड खोजने का कार्य दिया गया है, तो आप जनरेट किए गए मास्क को उलटने के लिए '--noncompliant' फ्लैग निर्दिष्ट कर सकते हैं:
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o noncompliant.hcmask -q --noncompliant
[*] जनरेट किए गए मास्क [noncompliant.hcmask] में सहेजे जा रहे हैं।
[*] गणनाओं के लिए 1,000,000,000 कुंजी/सेकंड का उपयोग किया जा रहा है।
[*] पासवर्ड नीति:
पास लंबाई: min:8 max:8
न्यूनतम शक्ति: l:1 u:1 d:1 s:1
अधिकतम शक्ति: l:None u:None d:None s:None
[*] [गैर-अनुपालन] मास्क जनरेट किए जा रहे हैं।
[*] 8 अक्षर वाले पासवर्ड मास्क जनरेट किए जा रहे हैं।
[*] कुल मास्क: 65536 समय: 76 दिन, 18:50:04
[*] नीति मास्क: 24712 समय: 41 दिन, 18:16:55
आइए '--showmasks' फ्लैग का उपयोग करके ऊपर जनरेट किए गए कुछ गैर-अनुपालन मास्क देखें:
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o noncompliant.hcmask -q --noncompliant --showmasks
[*] जनरेट किए गए मास्क [noncompliant.hcmask] में सहेजे जा रहे हैं।
[*] गणनाओं के लिए 1,000,000,000 कुंजी/सेकंड का उपयोग किया जा रहा है।
[*] पासवर्ड नीति:
पास लंबाई: min:8 max:8
न्यूनतम शक्ति: l:1 u:1 d:1 s:1
अधिकतम शक्ति: l:None u:None d:None s:None
[*] [गैर-अनुपालन] मास्क जनरेट किए जा रहे हैं।
[*] 8 अक्षर वाले पासवर्ड मास्क जनरेट किए जा रहे हैं।
[ 8] ?d?d?d?d?d?d?d?d [l: 0 u: 0 d: 8 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?l [l: 1 u: 0 d: 7 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?u [l: 0 u: 1 d: 7 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?s [l: 0 u: 0 d: 7 s: 1] [ 0:00:00]
...
[ 8] ?s?s?s?s?s?s?s?d [l: 0 u: 0 d: 1 s: 7] [ 0:07:06]
[ 8] ?s?s?s?s?s?s?s?l [l: 1 u: 0 d: 0 s: 7] [ 0:18:28]
[ 8] ?s?s?s?s?s?s?s?u [l: 0 u: 1 d: 0 s: 7] [ 0:18:28]
[ 8] ?s?s?s?s?s?s?s?s [l: 0 u: 0 d: 0 s: 8] [ 0:23:26]
[*] कुल मास्क: 65536 समय: 76 दिन, 18:50:04
[*] नीति मास्क: 24712 समय: 41 दिन, 18:16:55
जैसा कि आप देख सकते हैं, सभी मास्क में कम से कम एक पासवर्ड जटिलता आवश्यकता गायब है। दिलचस्प बात यह है कि कम मास्क जनरेट होने के बावजूद, लंबे समय तक चलने वाले मास्क जैसे '?s?s?s?s?s?s?s?s' के कारण हमला करने में अधिक समय लगता है।
अपने हमले को बारीकी से ट्यून करने के लिए --maxlower, --maxupper, --maxdigit और --maxspecial फ्लैग का उपयोग करके अधिकतम पासवर्ड जटिलता निर्दिष्ट करना भी संभव है। उदाहरण के लिए, नीचे एक नमूना साइट है जो पासवर्ड नीति लागू करती है लेकिन किसी भी विशेष वर्ण की अनुमति नहीं देती है:
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --maxspecial 0 -o maxcomplexity.hcmask -q
[*] जनरेट किए गए मास्क [maxcomplexity.hcmask] में सहेजे जा रहे हैं।
[*] गणनाओं के लिए 1,000,000,000 कुंजी/सेकंड का उपयोग किया जा रहा है।
[*] पासवर्ड नीति:
पास लंबाई: min:8 max:8
न्यूनतम शक्ति: l:1 u:1 d:1 s:None
अधिकतम शक्ति: l:None u:None d:None s:0
[*] [अनुपालन] मास्क जनरेट किए जा रहे हैं।
[*] 8 अक्षर वाले पासवर्ड मास्क जनरेट किए जा रहे हैं।
[*] कुल मास्क: 65536 समय: 76 दिन, 18:50:04
[*] नीति मास्क: 5796 समय: 1 दिन, 20:20:55
rulegen.py हैशकैट पासवर्ड क्रैकर के लिए पासवर्ड विश्लेषण और नियम निर्माण को लागू करता है, जैसा कि स्वचालित पासवर्ड नियम विश्लेषण और निर्माण पेपर में वर्णित है। नियम विश्लेषण और निर्माण के सिद्धांत पर विस्तृत चर्चा के लिए कृपया इस दस्तावेज़ की समीक्षा करें।
पहले से क्रैक किए गए पासवर्ड से स्रोत शब्दों और शब्द मैंगलिंग नियमों को उलटना एन्क्रिप्टेड हैश के विरुद्ध हमले करने में बहुत प्रभावी हो सकता है। जनरेट किए गए नियमों और शब्दों को लगातार रीसायकल/विस्तारित करके, आप अधिक पासवर्ड क्रैक करने में सक्षम हो सकते हैं।
rulegen.py के प्रभावी उपयोग के लिए कई आवश्यक शर्तें हैं। यह उपकरण एन्चैंट वर्तनी-जाँच लाइब्रेरी का उपयोग करके Aspell, MySpell, आदि जैसे कई वर्तनी-जाँच इंजनों के साथ इंटरफेस करता है। उपयोग से पहले आपको इन उपकरणों को स्थापित करना होगा। आप जिस भी वर्तनी-जाँच इंजन का उपयोग कर रहे हैं, उसके लिए शब्दकोश स्थापित करना भी महत्वपूर्ण है (वैकल्पिक रूप से कस्टम वर्डलिस्ट का उपयोग करना संभव है)। अंत में, मैंने सुविधा के लिए PyEnchant बंडल किया है जो सीधे Enchant की साझा लाइब्रेरीज़ के साथ इंटरफेस करना चाहिए; हालांकि, यदि कोई समस्या होती है, तो बस बंडल किए गए 'enchant' निर्देशिका को हटा दें और अपने वितरण के लिए PyEnchant स्थापित करें।
विशिष्ट हैशकैट नियम सिंटैक्स पर अतिरिक्त विवरण के लिए देखें हैशकैट नियम-आधारित हमला।
rulegen.py का सबसे बुनियादी उपयोग स्वचालित रूप से नियमों का पता लगाने के लिए एकल पासवर्ड का विश्लेषण करना शामिल है। आइए एक नमूना पासवर्ड P@55w0rd123 उत्पन्न करने के लिए उपयोग किए जाने वाले नियमों और संभावित स्रोत शब्द का पता लगाएं:
$ python rulegen.py --verbose --password P@55w0rd123
_
RuleGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Enchant 'aspell' मॉड्यूल का उपयोग कर रहे हैं। सर्वोत्तम परिणामों के लिए कृपया
'aspell' मॉड्यूल भाषा शब्दकोश स्थापित करें।
[*] पासवर्ड का विश्लेषण: P@55w0rd123
[-] Pas sword => {संपादन दूरी उप-इष्टतम: 8 (7)} => P@55w0rd123
[+] Password => sa@ ss5 so0 $1 $2 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 o81 $2 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 i81 o92 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 i81 i92 oA3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 o81 o92 $3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 o81 i92 oA3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 i81 o92 oA3 => P@55w0rd123
इस उदाहरण के लिए हमने कई फ्लैग का उपयोग किया है:
पासवर्ड फ़ाइलों को प्रोसेस करना नीचे एक अनुभाग में शामिल किया गया है; हालांकि, पहले एक उदाहरण के रूप में एकल पासवर्ड का उपयोग करके कुछ उपलब्ध बारीक ट्यूनिंग विकल्पों पर चर्चा करते हैं।
ध्यान दें कि स्रोत शब्द का पता लगाने के लिए हम aspell Enchant मॉड्यूल का उपयोग कर रहे हैं। सटीक वर्तनी-जाँच इंजन को निम्नानुसार --provider फ्लैग का उपयोग करके बदला जा सकता है:
$ python rulegen.py --verbose --provider myspell --password P@55w0rd123 -q
[*] Enchant 'myspell' मॉड्यूल का उपयोग कर रहे हैं। सर्वोत्तम परिणामों के लिए कृपया
'myspell' मॉड्यूल भाषा शब्दकोश स्थापित करें।
...
नोट: प्रदाता इंजन प्राथमिकता को अल्पविराम से अलग की गई सूची का उपयोग करके निर्दिष्ट किया जा सकता है (जैसे --provider aspell,myspell)।
--word फ्लैग के साथ एक स्रोत शब्द निर्दिष्ट करके स्रोत शब्द का पता लगाने वाले इंजन के उपयोग को पूरी तरह से अक्षम किया जा सकता है:
$ python rulegen.py -q --verbose --word word --password P@55w0rd123
[*] पासवर्ड का विश्लेषण: P@55w0rd123
[+] word => ^5 ^5 ^@ ^P so0 $1 $2 $3 => P@55w0rd123
विभिन्न स्रोत शब्द निर्दिष्ट करके आप नियम निर्माण इंजन के साथ प्रयोग करने में बहुत मज़ा ले सकते हैं।
अनिवार्य रूप से आप एक ऐसे बिंदु पर पहुँचेंगे जहाँ मानक वर्तनी-इंजन वर्डलिस्ट का उपयोग करके नियम उत्पन्न करना पर्याप्त नहीं रह जाता है। आप --wordlist फ्लैग का उपयोग करके एक कस्टम वर्डलिस्ट निर्दिष्ट कर सकते हैं। यह विशेष रूप से तब उपयोगी होता है जब पिछले विश्लेषण सत्र से स्रोत शब्दों का पुन: उपयोग किया जाता है:
$ python rulegen.py -q --verbose --wordlist rockyou.txt --password 1pa55w0rd1
[*] Enchant 'Personal Wordlist' मॉड्यूल का उपयोग कर रहे हैं। सर्वोत्तम परिणामों के लिए कृपया
'Personal Wordlist' मॉड्यूल भाषा शब्दकोश स्थापित करें।
[*] पासवर्ड का विश्लेषण: 1pa55w0rd1
[+] password => ^1 ss5 so0 $1 => 1pa55w0rd1
कस्टम वर्डलिस्ट विशेष रूप से तब उपयोगी हो सकती है जब आमतौर पर नहीं मिलने वाले शब्दों जैसे स्लैंग के साथ-साथ पहले से क्रैक किए गए पासवर्ड का उपयोग किया जाता है।
जबकि rulegen.py केवल सर्वोत्तम स्रोत शब्दों और पासवर्ड को उत्पन्न और रिकॉर्ड करने का प्रयास करता है, ऐसे मामले हो सकते हैं जहाँ आप अधिक परिणामों में रुचि रखते हैं। अधिकतम संपादन दूरी से अधिक होने वाले शब्दों और नियमों को उत्पन्न करने के लिए --morewords और --morerules फ्लैग का उपयोग करें:
$ python rulegen.py -q --verbose --password '$m0n3y$' --morerules --morewords
[*] Enchant 'aspell' मॉड्यूल का उपयोग कर रहे हैं। सर्वोत्तम परिणामों के लिए कृपया
'aspell' मॉड्यूल भाषा शब्दकोश स्थापित करें।
[*] पासवर्ड का विश्लेषण: $m0n3y$
[+] money => ^$ so0 se3 $$ => $m0n3y$
[+] moneys => ^$ so0 se3 o6$ => $m0n3y$
[+] mingy => ^$ si0 sg3 $$ => $m0n3y$
[+] many => ^$ sa0 i43 $$ => $m0n3y$
[+] Mooney => sM$ o1m so0 se3 $$ => $m0n3y$
--maxworddist और --maxwords फ्लैग का उपयोग करके उत्पन्न शब्दों को और विस्तारित करना संभव है। इसी तरह, आप --maxrulelen और --maxrules फ्लैग का उपयोग करके अधिक नियम उत्पन्न कर सकते हैं।
rulegen.py में बेहतर गुणवत्ता वाले शब्द और नियम उत्पन्न करने के लिए कई उन्नत इंजन शामिल हैं। --simplewords और --simplerules फ्लैग का उपयोग करके उन्हें अक्षम करना संभव है (या यदि वे समस्या पैदा कर रहे हैं तो)। आइए देखें कि इन फ्लैग के साथ स्रोत शब्द और नियम दोनों कैसे बदलते हैं:
$ python rulegen.py -q --verbose --password '$m0n3y$' --simplewords --simplerules
[*] Enchant 'aspell' मॉड्यूल का उपयोग कर रहे हैं। सर्वोत्तम परिणामों के लिए कृपया
'aspell' मॉड्यूल भाषा शब्दकोश स्थापित करें।
[*] पासवर्ड का विश्लेषण: $m0n3y$
[-] Meany => {संपादन दूरी उप-इष्टतम: 5 (4)} => $m0n3y$
[+] many => i0$ o20 i43 i6$ => $m0n3y$
[+] mingy => i0$ o20 o43 i6$ => $m0n3y$
[+] money => i0$ o20 o43 i6$ => $m0n3y$
[+] mangy => i0$ o20 o43 i6$ => $m0n3y$
[+] manky => i0$ o20 o43 i6$ => $m0n3y$
ध्यान दें कि उत्पन्न शब्दों और नियमों की गुणवत्ता काफी कम हो गई, जिसमें 'manky' जैसे शब्दों का वास्तविक स्रोत शब्द 'money' से कम संबंध था। साथ ही, उत्पन्न नियम केवल सरल सम्मिलन, विलोपन और प्रतिस्थापन तक सीमित हो गए।
अब जब आपने सभी विभिन्न फ्लैग और स्विच में महारत हासिल कर ली है, तो हम पासवर्ड के संग्रह के लिए शब्द और नियम उत्पन्न करने का प्रयास कर सकते हैं। आइए एक टेक्स्ट फ़ाइल korelogic.txt बनाएं जिसमें निम्नलिखित काफी जटिल परीक्षण पासवर्ड हों:
&~defcon
'#(4)\
August19681
'&a123456
10-D'Ann
~|Bailey
Krist0f3r
f@cebOOK
Nuclear$(
zxcvbn2010!
13Hark's
NjB3qqm
Sydney93?
antalya%]
Annl05de
;-Fluffy
अब आइए पहले तर्क के रूप में केवल पासवर्ड फ़ाइल निर्दिष्ट करके rulegen.py विश्लेषण का निरीक्षण करें:
$ python rulegen.py korelogic.txt -q
[*] Enchant 'aspell' मॉड्यूल का उपयोग कर रहे हैं। सर्वोत्तम परिणामों के लिए कृपया
'aspell' मॉड्यूल भाषा शब्दकोश स्थापित करें।
[*] पासवर्ड फ़ाइल का विश्लेषण: korelogic.txt:
[*] निष्पादन समाप्त करने और सांख्यिकीय विश्लेषण उत्पन्न करने के लिए Ctrl-C दबाएँ।
[*] नियमों को analysis.rule में सहेजा जा रहा है।
[*] शब्दों को analysis.word में सहेजा जा रहा है।
[*] 1.00 सेकंड में 15.94 पास/सेकंड की दर से 16 पासवर्ड प्रोसेस करना समाप्त हुआ।
[*] [analysis] नियमों और शब्दों के लिए आँकड़े उत्पन्न किए जा रहे हैं।
[-] 0 सभी संख्यात्मक पासवर्ड छोड़े गए (0.00%)
[-] 25% से कम वर्णमाला वर्ण वाले 2 पासवर्ड छोड़े गए (12.50%)
[-] 0 गैर-ASCII वर्ण वाले पासवर्ड छोड़े गए (0.00%)
[*] शीर्ष 10 नियम
[+] ^3 ^1 o4r - 3 (2.00%)
[+] i61 i79 i86 i98 oA1 - 2 (1.00%)
[+] ^- ^0 ^1 i4' o5A - 2 (1.00%)
[+] sS1 i13 T2 - 1 (0.00%)
[+] i61 se9 i86 i98 oA1 - 1 (0.00%)
[+] o61 i79 i86 i98 oA1 - 1 (0.00%)
[+] ^- ^0 ^1 so' i5A - 1 (0.00%)
[+] D3 si0 i55 $e - 1 (0.00%)
[+] i61 i79 se6 i98 oA1 - 1 (0.00%)
[+] i3a o5y o6a i7% o8] - 1 (0.00%)
[*] शीर्ष 10 शब्द
[+] Analyze - 1 (0.00%)
[+] defcon - 1 (0.00%)
[+] Kristen - 1 (0.00%)
[+] Bailey - 1 (0.00%)
[+] Augusts - 1 (0.00%)
[+] Annelid - 1 (0.00%)
[+] Hack's - 1 (0.00%)
[+] antlers - 1 (0.00%)
[+] antelope - 1 (0.00%)
[+] xxxv - 1 (0.00%)
सभी डिफ़ॉल्ट सेटिंग्स का उपयोग करके हम कई उच्च गुणवत्ता वाले नियम उत्पन्न करने में सक्षम थे। एप्लिकेशन कुछ बुनियादी शीर्ष 10 नियम और शब्द आँकड़े प्रदर्शित करता है। सभी उत्पन्न नियम और शब्द डिफ़ॉल्ट रूप से बेसनाम 'analysis' का उपयोग करके सहेजे जाते हैं:
ध्यान दें कि '#(4)\ और '&a123456 जैसे कई पासवर्ड छोड़ दिए गए क्योंकि उनमें प्रोसेस होने के लिए पर्याप्त विशेषताएँ नहीं हैं। वर्णमाला वर्ण गणना के अलावा, प्रोग्राम सभी संख्यात्मक पासवर्ड और गैर-ASCII वर्ण वाले पासवर्ड को छोड़ देगा। बाद वाला Enchant इंजन में एक बग के कारण है जिसे मैं भविष्य में ठीक करने की उम्मीद करता हूँ, इस प्रकार कई भाषाओं के शब्द प्रसंस्करण की अनुमति मिलेगी।
जैसा कि पहले उल्लेख किया गया है, rulegen.py डिफ़ॉल्ट रूप से 'analysis' बेसनाम का उपयोग करके आउटपुट फ़ाइलों को सहेजता है। आप निम्नानुसार --basename या -b फ्लैग के साथ फ़ाइल बेसनाम बदल सकते हैं:
$ python rulegen.py korelogic.txt -q -b korelogic
[*] Enchant 'aspell' मॉड्यूल का उपयोग कर रहे हैं। सर्वोत्तम परिणामों के लिए कृपया
'aspell' मॉड्यूल भाषा शब्दकोश स्थापित करें।
[*] पासवर्ड फ़ाइल का विश्लेषण: korelogic.txt:
[*] निष्पादन समाप्त करने और सांख्यिकीय विश्लेषण उत्पन्न करने के लिए Ctrl-C दबाएँ।
[*] नियमों को korelogic.rule में सहेजा जा रहा है।
[*] शब्दों को korelogic.word में सहेजा जा रहा है।
ऐसी स्थितियाँ हो सकती हैं जहाँ आपको हैशकैट पासवर्ड क्रैकर के लिए नियम उत्पन्न करने में समस्या आती है। rulegen.py में --stdout मोड में हैशकैट का उपयोग करके उत्पन्न शब्दों और नियमों को मान्य करने के लिए --hashcat फ्लैग शामिल है। इस मोड के ठीक से काम करने के लिए, आपको हैशकैट-क्ली का नवीनतम संस्करण डाउनलोड करना होगा और स्रोत में HASHCAT_PATH वेरिएबल को संपादित करना होगा। उदाहरण के लिए, इस लेखन के समय मैंने PACK निर्देशिका में हैशकैट-0.## फ़ोल्डर रखा है और HASHCAT_PATH को 'hashcat-0.##/' के रूप में परिभाषित किया है।
आप --debug फ्लैग के साथ नियम निर्माण इंजन के आंतरिक कामकाज को भी देख सकते हैं। कुछ नियम विफलताओं के संदेशों के बारे में चिंता न करें, यह एक इष्टतम और मान्य समाधान खोजने की कोशिश करने वाले हैल्टिंग समस्या सॉल्वर का परिणाम है।
जबकि यह मार्गदर्शिका पासवर्ड का विश्लेषण करने, नियमों को उलटने और मास्क उत्पन्न करने के कई तरीकों का परिचय देती है, ऐसी कई अन्य तरकीबें हैं जो आपके लिए खोजे जाने की प्रतीक्षा कर रही हैं। यदि आप मुझे किसी भी कवर किए गए उपकरण के कुछ असामान्य उपयोग या सुझाव के बारे में बताते हैं तो मुझे बहुत खुशी होगी।
हैप्पी क्रैकिंग!
-पीटर