Sprawdzanie siły hasła (jak sprawdzić warunki)

Hola

Najlepszym podejściem jest użycie wyszukiwania według wyrażeń regularnych

Oto funkcja, której obecnie używam

def password_check(password):

 """

 Verify the strength of 'password'

 Returns a dict indicating the wrong criteria

 A password is considered strong if:

 8 characters length or more

 1 digit or more

 1 symbol or more

 1 uppercase letter or more

 1 lowercase letter or more

 """ # calculating the length

 length_error = len(password) < 8 # searching for digits

 digit_error = re.search(r"\d", password) is None # searching for uppercase

 uppercase_error = re.search(r"[A-Z]", password) is None # searching for lowercase

 lowercase_error = re.search(r"[a-z]", password) is None # searching for symbols

 symbol_error = re.search(r"[ !#$%&'()*+,-./[\\\]^_`{|}~"+r'"]', password) is None # overall result

 password_ok = not ( length_error or digit_error or uppercase_error or lowercase_error or symbol_error ) return {

 'password_ok' : password_ok,

 'length_error' : length_error,

 'digit_error' : digit_error,

 'uppercase_error' : uppercase_error,

 'lowercase_error' : lowercase_error,

 'symbol_error' : symbol_error,

 }

EDIT:

Pod parą propozycja Łukasza tutaj jest aktualizacją specjalnego warunku sprawdzania symboli

symbol_error = re.search(r"\W", password) is None

password.isalnum ()

zwraca wartość logiczną, więc

password.isalnum () == hasło

jest zawsze

będzie

False

.
Po prostu pomiń część

== hasło

:

if password.lower()== password or password.upper()==password or password.isalnum():

 # ...

Co więcej, to

nigdy

nie może być jednocześnie cała góra i dół, ani cała góra i cyfry, ani całość dół i wszystkie liczby, więc drugi warunek (środek) jest niemożliwy. Może powinieneś poszukać dostępności

trochę

wielkie, małe litery i cyfry?
Jest jednak jeszcze jeden problem do rozwiązania. Sprawdzasz, czy hasło to

dosłownie

- cyfrowe, składające się wyłącznie ze znaków i/lub cyfr. Jeśli chcesz tylko sprawdzić liczby, użyj

.isdigit()

http://docs.python.org/2/libra ... digit
.
Możesz chcieć przeczytać

metody ciągów
http://docs.python.org/2/libra ... ds... Istnieją wygodne metody

.islower ()

i

.isupper ()

, które możesz wypróbować, na przykład:

>>> 'abc'.islower()

True

>>> 'abc123'.islower()

True

>>> 'Abc123'.islower()

False

>>> 'ABC'.isupper()

True

>>> 'ABC123'.isupper()

True

>>> 'Abc123'.isupper()

False

Są szybsze i mniej szczegółowe, że z

password.upper () == hasło

, poniższe testy sprawdzą to samo:

if password.isupper() or password.islower() or password.isdigit():

 # very weak indeed

Następną sztuczką, której chcesz się nauczyć, jest zapętlenie ciągu, abyś mógł sprawdzić poszczególne znaki:

>>> [c.isdigit() for c in 'abc123']

[False, False, False, True, True, True]

Jeśli połączysz to z funkcją

any ()

, możesz sprawdzić, czy jest

trochę

symbole będące liczbami:

>>> any(c.isdigit() for c in 'abc123')

True

>>> any(c.isdigit() for c in 'abc')

False

Myślę, że te techniki okażą się przydatne podczas testowania siły hasła.

Oto remake tego, co napisałeś:

import redef password():

 print ('Enter a password\n\nThe password must be between 6 and 12 characters.\n') while True:

 password = input('Password: ... ')

 if 6 <= len(password) < 12:

 break

 print ('The password must be between 6 and 12 characters.\n') password_scores = {0:'Horrible', 1:'Weak', 2:'Medium', 3:'Strong'}

 password_strength = dict.fromkeys(['has_upper', 'has_lower', 'has_num'], False)

 if re.search(r'[A-Z]', password):

 password_strength['has_upper'] = True

 if re.search(r'[a-z]', password):

 password_strength['has_lower'] = True

 if re.search(r'[0-9]', password):

 password_strength['has_num'] = True score = len([b for b in password_strength.values() if b]) print ('Password is %s' % password_scores[score])

Wyjście (próbka):

>>> password()

Enter a passwordThe password must be between 6 and 12 characters.Password: ... ghgG234

Password is Strong

Szukałem również funkcji sprawdzania siły hasła i znalazłem wiele niedopracowanych sugestii. Na tej podstawie zestawiłem swoją własną funkcję.
mam nadzieję, że pomogę

def get_pw_strength( pw ): s_lc = set(['a', 'c', 'b', 'e', 'd', 'g', 'f', 'i', 'h', 'k', 'j', 'm', 'l', 'o', 'n', 'q', 'p', 's', 'r', 'u', 't', 'w', 'v', 'y', 'x', 'z'])

 s_uc = set(['A', 'C', 'B', 'E', 'D', 'G', 'F', 'I', 'H', 'K', 'J', 'M', 'L', 'O', 'N', 'Q', 'P', 'S', 'R', 'U', 'T', 'W', 'V', 'Y', 'X', 'Z'])

 s_dg = set(['1', '0', '3', '2', '5', '4', '7', '6', '9', '8'])

 s_sp = set(['+', ',', '.', '-', '?', ':', '_', '(', ')', '*', '/', ';', '+', '!'])

 pw_s = 0

 pw_steps = (5, 8, 12)  pw_l = len(pw)

 if ( pw_l < 4 ):

 return 0

 for l in pw_steps :

 if ( pw_l > l ):

 pw_s += 1

 #print "length over ", l," giving point", pw_s c_lc = c_uc = c_dg = c_sp = 0

 for c in pw :

 if ( c in s_lc ) :

 c_lc += 1

 if ( c in s_uc ) :

 c_uc += 1

 if ( c in s_dg ) :

 c_dg += 1

 if ( c in s_sp ) :

 c_sp += 1

 if ( c_lc + c_uc + c_dg + c_sp <> pw_l ):

 #print c_lc, c_uc, c_dg, c_sp, pw_l

 #raise Exception "Forbidden chracter"

 return -1

 charset = 0

 if ( c_lc ) :

 pw_s += 1

 charset = len(s_lc)

 if ( c_uc ) :

 pw_s += 1

 charset = len(s_uc)

 if ( c_dg ) :

 pw_s += 1

 charset = len(s_dg)

 if ( c_sp ) :

 pw_s += 2

 charset = len(s_sp)

 entropy = log(pow(charset,pw_l),2) return pw_s, entropy