Build a Python Password Strength Checker (Step-by-Step)

Want to create a robust Python password strength checker to analyze password security? This project will guide you through building a command-line tool that evaluates the strength of a password based on entropy, length, and character diversity.

What You Will Learn:

- Understanding password strength evaluation
- Using entropy for password security analysis
- Implementing getpass for secure password input
- Validating user input and character diversity
- Creating a loop for multiple checks

Step 1: Setting Up the Project

Before we start coding, let’s set up our Python project:

1. Make sure Python is installed on your computer. If not, download it from the official Python website.
2. Open your favorite code editor or IDE.
3. Create a new Python file, for example, password_checker.py.

Great, now, let's dive head first into our Python editor to get this build started.

Step 2: Understanding How the Password Strength Checker Works

Our program will:

• Prompt the user to enter a password securely using getpass.
• Evaluate the password’s strength based on length, character variety, and entropy.
• Provide feedback on password quality and improvements.
• Allow the user to check multiple passwords in a loop until they decide to exit.

Step 3: Importing Required Modules

We need three Python modules:

import random # For generating random numbers import os # To clear the screen 

Why Do We Use These Modules?

• string → Provides predefined character sets (lowercase, uppercase, digits, special characters).

• getpass → Allows secure password entry without displaying it on the screen.

• math → Used to calculate password entropy for strength evaluation.

Now that we have our required modules, let's move on to defining our functions.

Step 4: Implementing Password Entropy Calculation

Let's start by writing the core password evaluation functions.

MIN_LENGTH = 8 # Minimum recommended password length def calculate_entropy(password): """Calculates entropy based on character diversity and length.""" charset_size = 0 if any(c in string.ascii_lowercase for c in password): charset_size += 26 if any(c in string.ascii_uppercase for c in password): charset_size += 26 if any(c in string.digits for c in password): charset_size += 10 if any(c in string.punctuation for c in password): charset_size += len(string.punctuation) if any(c.isspace() for c in password): charset_size += 1 return len(password) * math.log2(charset_size) if charset_size else 0

How It Works:

• Identifies character diversity by checking if the password contains lowercase, uppercase, digits, special characters, or spaces.

• Uses entropy calculation to determine password strength using the formula entropy = length * log2(character_set_size).

• Higher entropy = stronger password, making it harder for attackers to guess.

Why Do We Use Entropy?

Entropy is a scientific measure of password strength. Instead of just checking if a password contains numbers or symbols, entropy estimates how unpredictable a password is:

• Higher entropy → More combinations → Harder to crack.

• Lower entropy → Easier to guess → Weaker security.

By using entropy-based evaluation, we provide a better security analysis rather than just counting characters.

Now that we have password entropy in place, let’s proceed to evaluating password strength and user feedback.

Step 5: Checking Password Strength

Now, let's implement the function that analyzes password strength and provides feedback:

def check_password_strength(): """Evaluates password strength based on entropy and diversity.""" password = getpass.getpass('Enter your password: ') if len(password) < MIN_LENGTH: print(f"⚠️ Your password is too short! It must be at least {MIN_LENGTH} characters.") return lower_count = sum(1 for c in password if c in string.ascii_lowercase) upper_count = sum(1 for c in password if c in string.ascii_uppercase) num_count = sum(1 for c in password if c in string.digits) special_count = sum(1 for c in password if c in string.punctuation) wspace_count = sum(1 for c in password if c.isspace()) entropy = calculate_entropy(password) # Classifying password strength if entropy < 28: remarks = "⚠️ Very Weak: Easily guessable! Change it immediately." elif entropy < 36: remarks = "⚠️ Weak: Can be cracked quickly. Use a stronger password." elif entropy < 60: remarks = "✅ Moderate: Decent password, but can still be improved." elif entropy < 80: remarks = "✅ Strong: Hard to guess, but consider making it longer." else: remarks = "✅ Very Strong: Excellent password! Highly secure." # Display password analysis print("\n🔎 Password Analysis:") print(f"🔹 {lower_count} lowercase letters") print(f"🔹 {upper_count} uppercase letters") print(f"🔹 {num_count} digits") print(f"🔹 {special_count} special characters") print(f"🔹 {wspace_count} whitespace characters") print(f"🔹 Entropy Score: {entropy:.2f} bits") print(f"🔹 Remarks: {remarks}\n")

How It Works:

• Analyzes password diversity by counting lowercase, uppercase, digits, special characters, and whitespace.

• Uses entropy score to classify the strength of the password.

• Provides clear feedback on how secure the password is via various Python f-strings.

By implementing this analysis, users get a comprehensive breakdown of their password’s security level.

Now that we can evaluate password strength, let’s move on to looping the process for multiple checks.

Step 6: Looping for Multiple Checks

To allow users to check multiple passwords, we add a while loop:

def check_another_password(): """Asks the user if they want to check another password.""" while True: choice = input("🔄 Do you want to check another password? (y/n): ").strip().lower() if choice == 'y': return True elif choice == 'n': print("👋 Exiting... Stay secure!") return False else: print("⚠️ Invalid input. Please enter 'y' or 'n'.")

How It Works:

• Continuously prompts users to check another password.

• Ensures only valid responses (y for yes, n for no) are accepted.

• Provides a smooth user experience by keeping the program interactive.

By implementing this, users can evaluate multiple passwords in a single session.

Now that we have an interactive password checker, let’s move on to finalizing the program execution.

Step 7: Running the Program

Finally, we ensure the script runs correctly when executed:

if __name__ == '__main__': print("===== 🔑 Welcome to Password Strength Checker 🔑 =====") while check_another_password(): check_password_strength()

Why Is This Needed?

• Ensures the script runs only when executed directly.

• Prevents unintended execution when imported as a module.

• Creates a structured workflow that loops through password checks.

By using this structure, we keep the program organized, user-friendly, and maintainable. Now, your password strength checker is fully functional and ready to use.

Final Code: Password Strength Checker

import string # For checking character diversity import getpass # For secure password input import math # For entropy calculation # Minimum recommended password length MIN_LENGTH = 8 def calculate_entropy(password): """Calculates entropy based on character diversity and length.""" charset_size = 0 if any(c in string.ascii_lowercase for c in password): charset_size += 26 if any(c in string.ascii_uppercase for c in password): charset_size += 26 if any(c in string.digits for c in password): charset_size += 10 if any(c in string.punctuation for c in password): charset_size += len(string.punctuation) if any(c.isspace() for c in password): charset_size += 1 return len(password) * math.log2(charset_size) if charset_size else 0 def check_password_strength(): """Evaluates password strength based on entropy and diversity.""" password = getpass.getpass('Enter your password: ') if len(password) < MIN_LENGTH: print(f"⚠️ Your password is too short! It must be at least {MIN_LENGTH} characters.") return lower_count = sum(1 for c in password if c in string.ascii_lowercase) upper_count = sum(1 for c in password if c in string.ascii_uppercase) num_count = sum(1 for c in password if c in string.digits) special_count = sum(1 for c in password if c in string.punctuation) wspace_count = sum(1 for c in password if c.isspace()) entropy = calculate_entropy(password) # Classifying password strength if entropy < 28: remarks = "⚠️ Very Weak: Easily guessable! Change it immediately." elif entropy < 36: remarks = "⚠️ Weak: Can be cracked quickly. Use a stronger password." elif entropy < 60: remarks = "✅ Moderate: Decent password, but can still be improved." elif entropy < 80: remarks = "✅ Strong: Hard to guess, but consider making it longer." else: remarks = "✅ Very Strong: Excellent password! Highly secure." # Display password analysis print("\n🔎 Password Analysis:") print(f"🔹 {lower_count} lowercase letters") print(f"🔹 {upper_count} uppercase letters") print(f"🔹 {num_count} digits") print(f"🔹 {special_count} special characters") print(f"🔹 {wspace_count} whitespace characters") print(f"🔹 Entropy Score: {entropy:.2f} bits") print(f"🔹 Remarks: {remarks}\n") def check_another_password(): """Asks the user if they want to check another password.""" while True: choice = input("🔄 Do you want to check another password? (y/n): ").strip().lower() if choice == 'y': return True elif choice == 'n': print("👋 Exiting... Stay secure!") return False else: print("⚠️ Invalid input. Please enter 'y' or 'n'.") if __name__ == '__main__': print("===== 🔑 Welcome to Password Strength Checker 🔑 =====") while check_another_password(): check_password_strength() 

Wrapping Up

Congratulations! You’ve built a fully functional Password Strength Checker in Python.

What You Learned:

- Password entropy calculation
- Validating password length and diversity
- Secure password input using getpass
- Continuous password checks with a loop

Next Steps:

- Add a password breach check using HaveIBeenPwned API.
- Suggest stronger passphrase alternatives if a password is weak.
- Build a GUI version using Tkinter or PyQt.

The best way to learn is by building projects, so keep coding!