पासवर्ड की ताकत के बारे में विभिन्न संसाधनों को पढ़ने के बाद, मैं एक एल्गोरिथ्म बनाने की कोशिश कर रहा हूं, जो एक पासवर्ड कितना एंट्रॉपी है, इसका मोटा अनुमान प्रदान करेगा।
मैं एक एल्गोरिथ्म बनाने की कोशिश कर रहा हूं जो यथासंभव व्यापक है। इस बिंदु पर मेरे पास केवल pseudocode है, लेकिन एल्गोरिथ्म में निम्नलिखित शामिल हैं:
- पारण शब्द लम्बाई
- दोहराए गए पात्र
- पैटर्न (तार्किक)
- विभिन्न वर्ण स्थान (LC, UC, न्यूमेरिक, स्पेशल, एक्सटेंडेड)
- शब्दकोश हमलों
यह निम्नलिखित को कवर नहीं करता है, और इसे कवर किया जाना चाहिए (हालांकि पूरी तरह से नहीं):
- ऑर्डर करना (इस एल्गोरिदम के आउटपुट द्वारा पासवर्ड सख्ती से ऑर्डर किए जा सकते हैं)
- पैटर्न (स्थानिक)
किसी को भी इस एल्गोरिथ्म क्या कमजोर हो सकता है पर कुछ अंतर्दृष्टि प्रदान कर सकते हैं? विशेष रूप से, क्या कोई ऐसी स्थितियों के बारे में सोच सकता है जहां एल्गोरिदम को पासवर्ड खिलाते समय इसकी ताकत बढ़ जाएगी ? कम आंकना किसी मुद्दे से कम नहीं है।
एल्गोरिथ्म:
// the password to test
password = ?
length = length(password)
// unique character counts from password (duplicates discarded)
uqlca = number of unique lowercase alphabetic characters in password
uquca = number of uppercase alphabetic characters
uqd = number of unique digits
uqsp = number of unique special characters (anything with a key on the keyboard)
uqxc = number of unique special special characters (alt codes, extended-ascii stuff)
// algorithm parameters, total sizes of alphabet spaces
Nlca = total possible number of lowercase letters (26)
Nuca = total uppercase letters (26)
Nd = total digits (10)
Nsp = total special characters (32 or something)
Nxc = total extended ascii characters that dont fit into other categorys (idk, 50?)
// algorithm parameters, pw strength growth rates as percentages (per character)
flca = entropy growth factor for lowercase letters (.25 is probably a good value)
fuca = EGF for uppercase letters (.4 is probably good)
fd = EGF for digits (.4 is probably good)
fsp = EGF for special chars (.5 is probably good)
fxc = EGF for extended ascii chars (.75 is probably good)
// repetition factors. few unique letters == low factor, many unique == high
rflca = (1 - (1 - flca) ^ uqlca)
rfuca = (1 - (1 - fuca) ^ uquca)
rfd = (1 - (1 - fd ) ^ uqd )
rfsp = (1 - (1 - fsp ) ^ uqsp )
rfxc = (1 - (1 - fxc ) ^ uqxc )
// digit strengths
strength =
( rflca * Nlca +
rfuca * Nuca +
rfd * Nd +
rfsp * Nsp +
rfxc * Nxc ) ^ length
entropybits = log_base_2(strength)
कुछ इनपुट और उनके वांछित और वास्तविक एंट्रॉपी_बिट आउटपुट:
INPUT DESIRED ACTUAL
aaa very pathetic 8.1
aaaaaaaaa pathetic 24.7
abcdefghi weak 31.2
H0ley$Mol3y_ strong 72.2
s^fU¬5ü;y34G< wtf 88.9
[a^36]* pathetic 97.2
[a^20]A[a^15]* strong 146.8
xkcd1** medium 79.3
xkcd2** wtf 160.5
* these 2 passwords use shortened notation, where [a^N] expands to N a's.
** xkcd1 = "Tr0ub4dor&3", xkcd2 = "correct horse battery staple"
एल्गोरिथ्म का एहसास (सही ढंग से) होता है जो वर्णमाला के आकार (एक अंक से भी) को बढ़ाकर काफी हद तक लंबे पासवर्ड को मजबूत करता है, जैसा कि 6 वें और 7 वें पासवर्ड के लिए एन्ट्रापी_बिट्स के अंतर से दिखाया गया है, जिसमें दोनों में 36 ए शामिल है, लेकिन दूसरे 21 वें स्थान पर है पूंजीकृत। हालांकि, वे इस तथ्य के लिए जिम्मेदार नहीं हैं कि 36 ए का पासवर्ड होना एक अच्छा विचार नहीं है, यह एक कमजोर पासवर्ड क्रैकर के साथ आसानी से टूट गया है (और जो कोई भी आपको देखता है वह इसे देखेगा) और एल्गोरिथ्म प्रतिबिंबित नहीं करता है ।
हालाँकि, यह इस तथ्य को दर्शाता है कि xkcd2 xkcd2 की तुलना में एक कमजोर पासवर्ड है, अधिक जटिलता घनत्व होने के बावजूद (क्या यह भी एक बात है?)।
मैं इस एल्गोरिथ्म को कैसे सुधार सकता हूं?
परिशिष्ट 1
डिक्शनरी अटैक और पैटर्न बेस्ड अटैक बड़ी बात लगती है, इसलिए मैं उन लोगों को संबोधित करूंगा।
मैं एक शब्द सूची से शब्दों के लिए पासवर्ड के माध्यम से एक व्यापक खोज कर सकता था और टोकन को शब्दों से बदल सकता हूं जो वे प्रतिनिधित्व करते हैं। वर्ड-टोकन तब वर्णों के रूप में माने जाएंगे और उनकी खुद की भार प्रणाली होगी, और पासवर्ड के लिए अपना वजन जोड़ेंगे। मुझे कुछ नए एल्गोरिथ्म मापदंडों की आवश्यकता होगी (मैं उन्हें lw, Nw ~ 2 ^ 11, fw ~ = .5, और rfw कहूंगा) और मैं पासवर्ड को वज़न में कारक मानूँगा क्योंकि मैं अन्य में से कोई भी करूँगा। वजन।
इस शब्द खोज को विशेष रूप से लोअरकेस और अपरकेस अक्षरों के साथ-साथ आम चरित्र प्रतिस्थापनों से मेल करने के लिए संशोधित किया जा सकता है, जैसे कि ई के साथ 3.। अगर मैं ऐसे मिलान किए गए शब्दों में अतिरिक्त वजन नहीं जोड़ता था, तो एल्गोरिथ्म थोड़ा सा अपनी ताकत को कम करेगा। या प्रति शब्द दो, जो ठीक है। अन्यथा, एक सामान्य नियम होगा, प्रत्येक गैर-परिपूर्ण चरित्र मैच के लिए, शब्द को बोनस बिट प्रदान करें।
मैं तब सरल पैटर्न जाँच कर सकता था, जैसे कि बार-बार वर्ण और व्युत्पन्न परीक्षणों के रन की खोज (प्रत्येक वर्ण के बीच का अंतर), जो 'आआआ' और '12345' जैसे पैटर्न की पहचान करेगा, और प्रत्येक ज्ञात पैटर्न को एक पैटर्न के साथ बदल देगा। टोकन, पैटर्न और लंबाई के लिए अद्वितीय है। एल्गोरिदमिक पैरामीटर (विशेष रूप से, प्रति पैटर्न एंट्रोपी) पैटर्न के आधार पर मक्खी पर उत्पन्न हो सकते हैं।
इस बिंदु पर, मैं पासवर्ड की लंबाई लूंगा। प्रत्येक शब्द टोकन और पैटर्न टोकन एक चरित्र के रूप में गिना जाएगा; प्रत्येक टोकन उन पात्रों की जगह लेगा, जिनका वे प्रतीकात्मक रूप से प्रतिनिधित्व करते थे।
मैंने पैटर्न नोटेशन के कुछ प्रकार बनाए, लेकिन इसमें पैटर्न लंबाई l, पैटर्न ऑर्डर ओ और बेस एलिमेंट b शामिल हैं। इस जानकारी का उपयोग प्रत्येक पैटर्न के लिए कुछ मनमाने वजन की गणना करने के लिए किया जा सकता है। मैं वास्तविक कोड में कुछ बेहतर करूँगा।
संशोधित उदाहरण:
Password: 1234kitty$$$$$herpderp
Tokenized: 1 2 3 4 k i t t y $ $ $ $ $ h e r p d e r p
Words Filtered: 1 2 3 4 @W5783 $ $ $ $ $ @W9001 @W9002
Patterns Filtered: @P[l=4,o=1,b='1'] @W5783 @P[l=5,o=0,b='$'] @W9001 @W9002
Breakdown: 3 small, unique words and 2 patterns
Entropy: about 45 bits, as per modified algorithm
Password: correcthorsebatterystaple
Tokenized: c o r r e c t h o r s e b a t t e r y s t a p l e
Words Filtered: @W6783 @W7923 @W1535 @W2285
Breakdown: 4 small, unique words and no patterns
Entropy: 43 bits, as per modified algorithm
पैटर्न से एन्ट्रापी की गणना कैसे की जाती है इसका सटीक शब्दार्थ चर्चा के लिए है। मैं कुछ सोच रहा था:
entropy(b) * l * (o + 1) // o will be either zero or one
संशोधित एल्गोरिथ्म मूल सारणी में प्रत्येक पासवर्ड की खामियों को कम करेगा, इसके अपवाद के साथ s^fU¬5ü;y34G<, जिसमें कोई शब्द या पैटर्न नहीं है।