Kontrollera din lösenordssäkerhet med Python

Data är en viktig tillgång i dagens digitala värld. Mer än åtta miljoner människor faller offer för hackare varje år och mer än 2200 cyberattacker äger rum varje dag. Med en sådan alarmerande hastighet av cyberbrottslighet blir det en prioritet att använda bästa praxis för att skydda mot hackare. En av de viktigaste aspekterna av alla konton är dess lösenord.

Om en hackare äventyrar ditt lösenord kan de få tillgång till din personliga information, och till och med ditt bankkonto, på några minuter. Även om detta låter skrämmande kan du lära dig hur du säkrar dina lösenord med hjälp av bästa praxis genom att bygga ditt eget Python-program för att kontrollera dess styrka.

Olika regler för att ställa in starka lösenord

Några starka lösenordsregler du kan tänka dig att implementera är:

1. Lösenordet bör vara minst 12 tecken långt. Ju längre lösenordet är, desto mindre är chansen att en brute force-attack äventyrar det.
instagram viewer
2. Lösenordet bör innehålla en kombination av små bokstäver, versaler, siffror och specialtecken.
3. Undvik att upprepa tecken i lösenordet.
4. Det bör inte innehålla personliga uppgifter som namn, telefonnummer eller något som någon lätt kan gissa.
5. Det borde inte vara ett vanligt ordboksord, även om du kan använda ord i längre lösenordsfraser.
6. Lösenordet bör inte vara detsamma för flera konton. Du kan konfigurera en lösenordshanterare att autofylla olika lösenord för olika webbplatser utan att komma ihåg var och en av dem.

Det finns olika sätt att skapa ett okrossbart lösenord som du kan komma ihåg. Några av dem använder barnrim, citat från filmer, industrispråk och mer.

Hur du kontrollerar din lösenordsstyrka med Python

Du kan bygga ett program för att testa lösenordsstyrkan genom att kontrollera ovanstående egenskaper. För denna konstruktion behöver du två moduler: sträng och samlingar.

Du kan också använda getpass modul för att dölja ett lösenord när användaren anger det. Detta hjälper till att skydda ditt lösenord när du måste skriva det offentligt. För att installera getpass i din lokala miljö, öppna en terminal och skriv:

pip Installera getpass4

Du kan använda klassen String för att kontrollera om ett tecken är en bokstav, siffra eller symbol. Du kan använda samlingar för att kontrollera om det finns tecken i lösenordet som upprepas.

Använd nyckelordet def för att definiera en funktion som heter check_password_strength() och skicka lösenordet du får som parameter till den.

Initiera sex variabler: lägre_alfaantal, upper_alpha_count, antal_antal, special_char_count, längd, allmänning till noll. Dessa kommer att kontrollera förekomsten av gemener, versaler, siffror, specialtecken, längd, upprepning av tecken i ett lösenord.

Skicka lösenordet du får från användaren till lista() funktion för att konvertera den till en lista med tecken. Använd for-slingan, iterera över varje tecken i listan. Använd if-else-satsen för att kontrollera om tecknet är ett gement alfabet, versaler, tal eller ett specialtecken och uppdatera antalet respektive.

Du kan anta att allt annat från alfabetet eller siffran är ett specialtecken. För mer begränsning kan du lagra specialtecken som en sträng och kontrollera om lösenordets tecken finns i den. Dessutom tillåter vissa webbplatser dig att använda blanksteg i ett lösenord. Du kan ställa in en annan variabel och öka den eller ta hänsyn till den i själva antalet specialtecken.

importera sträng
importera samlingar
defcheck_password_strength(Lösenord):
 lower_alpha_count = övre_alpha_count = number_count = special_char_count = längd = vanligt = 0
för röding i lista(Lösenord):
omröding i string.ascii_lowercase:
 lower_alpha_count += 1
 elif röding i string.ascii_versaler:
 upper_alpha_count += 1
 elif röding i string.digits:
 antal_antal += 1
annan:
 special_char_count += 1

Du behöver en lösenordslista eller databas för att kontrollera om användarens lösenord är vanligt. Du kan ladda ner en lista över en miljon mest populära lösenord från SecLists Common-Credential GitHub-förråd.

Spara textfilen som common_password_list.txt. Använd with-satsen för att utföra undantagshantering och öppna lösenordsfilen i läsläge. Använd läsa() funktion för att få innehållet närvarande i filen och lagra det i en variabel med namnet innehåll.

Om lösenordet som användaren anger inte finns i den gemensamma lösenordslistan, öka värdet på den gemensamma variabeln med en.

medöppen("common_password_list.txt", 'r') somfil:
 content = file.read()
 om lösenordet inte finns i innehållet:
 vanligt += 1

För att kontrollera längden på lösenordet, skicka det helt enkelt till len() funktion och kontrollera om den är större än eller lika med tolv. Om så är fallet, öka värdet på längdvariabeln.

omlen(Lösenord) >= 12:
 längd += 1 

För att kontrollera efter upprepning av tecken i lösenord, använd underklassen Counter från Collections. Räknare är en oordnad samling nyckel- och värdepar där nyckeln är själva elementet och värdet är antalet element.

Använd listförståelsemetoden för att skapa en lista med upprepade tecken från ordboken du får med hjälp av samlingar. Iterera över ordboken och kontrollera om antalet tecken är större än ett. Om antalet är större, lägg till det i en lista och lagra det i upprepad.

 countOfWords = samlingar. Räknare (lösenord)
 upprepad = [i för i i countOfWords om countOfWords[i] > 1]

Nu när du har värdena för de individuella egenskaperna, initiera en variabel som heter styrka till noll. Som namnet antyder kommer du att se denna variabel för att kontrollera lösenordets styrka. Poängsystemet är av sju, en poäng för varje införande av en karaktär och egenskap hos ett starkt lösenord.

Kontrollera om antalet gemener, versaler, siffror, specialtecken är större än eller lika med ett och öka styrkan med ett för varje närvaro. Kontrollera på samma sätt om längden och den gemensamma variabeln är lika med ett och om längden på upprepade tecken är lika med noll. Om det är sant, öka värdet på styrkavariabeln.

 styrka = 0
 om lägre_alfaantal >= 1:
 styrka += 1
 om upper_alpha_count >= 1:
 styrka += 1
 om antal_antal >= 1:
 styrka += 1
 om special_char_count >= 1:
 styrka += 1
 om längd == 1:
 styrka += 1
 om vanligt == 1:
 styrka += 1
omlen(upprepad)== 0:
 styrka += 1

Använd flerradssträngen (tre citattecken) för att visa flera textrader i en enda utskriftssats. Använd den bokstavliga Sring Interpolation eller f-strängar eller för att visa antalet egenskaper. Du kan uppnå detta genom att skriva f i början av strängen i print-satsen och omge variablerna inom parentes. Du använder stränginterpolation eftersom innehållet i printsatsen är en sträng, men värdet på variablerna är ett heltal.

skriva ut(f"""Ditt lösenord har:- 
 {lower_alpha_count} små bokstäver 
 {upper_alpha_count} versaler
 {number_count} siffror
 {special_char_count} specialtecken
 {length} längd
 {common} vanligt
 {repeated} upprepades
"Lösenordspoäng: {styrka}/7""")

Använd slutligen inmatningssatsen för att ta emot lösenordet från användaren och skicka det till check_password_strength fungera. Baserat på lösenordets styrka kommer programmet att visa poängen tillsammans med antalet egenskaper som finns i lösenordet.

lösenord = input("Ange lösenordet:")
check_password_strength (lösenord)

Utdata från kontroll av lösenordsstyrka

När du anger ett starkt lösenord baserat på de nämnda egenskaperna visar Python-programmet styrkan som 7/7:

När du anger ett svagt och vanligt lösenord visar Python-programmet styrkan som 1/7:

Lösenord och säkerhet

Även om du kan ställa in det starkaste lösenordet någonsin, finns det andra sätt som en hackare kan bryta sig in i ditt system. 95 % av cyberattackerna är ett resultat av mänskliga misstag. En av de vanligaste metoderna som hackare använder är social ingenjörskonst. Hackaren kan skicka dig förfalskade länkar till sociala medier eller e-handelswebbplatser som ser legitima ut, men äventyrar ditt lösenord om du använder dem.

För att skydda mot dessa tekniker, se till att endast öppna länkar från en pålitlig källa och endast ange eller lagra viktig information säkert.