Setelah membaca berbagai sumber tentang kekuatan kata sandi, saya mencoba membuat algoritma yang akan memberikan perkiraan kasar tentang seberapa banyak entropi kata sandi.
Saya mencoba membuat algoritma yang selengkap mungkin. Pada titik ini saya hanya memiliki pseudocode, tetapi algoritma mencakup yang berikut:
- panjang kata sandi
- karakter yang diulang
- pola (logis)
- ruang karakter berbeda (LC, UC, Numerik, Khusus, Diperpanjang)
- serangan kamus
Ini TIDAK mencakup yang berikut, dan HARUS menutupinya BAIK (walaupun tidak sempurna):
- pemesanan (kata sandi dapat dipesan secara ketat oleh output dari algoritma ini)
- pola (spasial)
Adakah yang bisa memberikan beberapa wawasan tentang apa algoritma ini mungkin lemah? Secara khusus, adakah yang bisa memikirkan situasi di mana memasukkan kata sandi ke algoritma akan melebih - lebihkan kekuatannya? Meremehkan kurang menjadi masalah.
Algoritma:
// 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)
Beberapa input dan output entropy_bits yang diinginkan dan aktual:
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"
Algoritma tidak menyadari (dengan benar) bahwa meningkatkan ukuran alfabet (bahkan satu digit) sangat memperkuat kata sandi yang panjang, seperti yang ditunjukkan oleh perbedaan dalam entropy_bits untuk kata sandi ke-6 dan ke-7, yang keduanya terdiri dari 36 a, tetapi yang kedua adalah a. dikapitalisasi. Namun, mereka tidak memperhitungkan fakta bahwa memiliki kata sandi 36 a bukanlah ide yang baik, itu mudah rusak dengan cracker kata sandi yang lemah (dan siapa pun yang melihat Anda mengetiknya akan melihatnya) dan algoritma tidak mencerminkan bahwa .
Namun, hal itu mencerminkan fakta bahwa xkcd1 adalah kata sandi yang lemah dibandingkan dengan xkcd2, walaupun memiliki kepadatan kompleksitas yang lebih besar (apakah ini bahkan masalah?).
Bagaimana saya dapat meningkatkan algoritma ini?
Adendum 1
Serangan kamus dan serangan berbasis pola tampaknya menjadi hal besar, jadi saya akan berusaha keras untuk mengatasinya.
Saya bisa melakukan pencarian komprehensif melalui kata sandi untuk kata-kata dari daftar kata dan mengganti kata-kata dengan token yang unik untuk kata-kata yang diwakilinya. Token kata kemudian akan diperlakukan sebagai karakter dan memiliki sistem bobotnya sendiri, dan akan menambah bobotnya sendiri ke kata sandi. Saya memerlukan beberapa parameter algoritma baru (saya akan memanggil mereka lw, Nw ~ = 2 ^ 11, fw ~ = .5, dan rfw) dan saya akan memasukkan bobot ke dalam kata sandi seperti saya akan salah satu dari yang lain beban.
Pencarian kata ini dapat secara khusus dimodifikasi untuk mencocokkan huruf kecil dan besar serta penggantian karakter umum, seperti E dengan 3. Jika saya tidak menambah bobot ekstra untuk kata-kata yang cocok seperti itu, algoritma akan meremehkan kekuatan mereka sedikit. atau dua per kata, yang OK. Kalau tidak, aturan umum akan, untuk setiap pertandingan karakter yang tidak sempurna, berikan sedikit kata bonus.
Saya kemudian dapat melakukan pengecekan pola sederhana, seperti pencarian untuk run karakter berulang dan tes turunan (mengambil perbedaan antara masing-masing karakter), yang akan mengidentifikasi pola seperti 'aaaaa' dan '12345', dan mengganti setiap pola yang terdeteksi dengan pola token, unik untuk pola dan panjangnya. Parameter algoritmik (khususnya, entropi per pola) dapat dihasilkan dengan cepat berdasarkan pola.
Pada titik ini, saya akan mengambil kata sandi yang panjang. Setiap kata token dan pola token akan dihitung sebagai satu karakter; setiap token akan menggantikan karakter yang diwakili secara simbolis.
Saya membuat semacam notasi pola, tetapi itu mencakup panjang pola l, urutan pola o, dan elemen dasar b. Informasi ini dapat digunakan untuk menghitung bobot acak untuk setiap pola. Saya akan melakukan sesuatu yang lebih baik dalam kode aktual.
Contoh yang Dimodifikasi:
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
Semantik yang tepat tentang bagaimana entropi dihitung dari pola siap untuk dibahas. Saya sedang memikirkan sesuatu seperti:
entropy(b) * l * (o + 1) // o will be either zero or one
Algoritma yang dimodifikasi akan menemukan kekurangan dengan dan mengurangi kekuatan setiap kata sandi dalam tabel asli, dengan pengecualian s^fU¬5ü;y34G<
, yang tidak mengandung kata atau pola.