Strong password creation program in Python with code

So, I'm going to write a Python program to generate strong, unhackable passwords. First, I need to see what characteristics a strong password has. Usually, it needs to be long, have a mix of uppercase and lowercase letters, numbers, and special characters. So I need to consider these.

First, I think I need to use the random module to randomly select characters. I might also need the string module to get the required character set. For example, string.ascii_letters for uppercase and lowercase letters, string.digits for numbers, and string.punctuation for special characters. Then, I need to determine the length of the password. It's usually recommended to be at least 12 characters. It might be better if the user can specify the length, so I'll consider an optional parameter for the function.

I need to make sure that the generated password has at least one instance of each character class. For example, one uppercase letter, one lowercase letter, one number, and one special character. This way, the probability of the password being weak is reduced. After creating the password, I need to check if it meets the conditions. If not, I need to create the password again. This may require a while loop until all the conditions are met. I also need to allow the user to choose the level of security. For example, low level only letters and numbers, medium level letters, numbers and special characters, and high level everything with longer length. I might add this part to the function with other parameters. The user may want to create more passwords, so I design the function to generate and display multiple passwords.

Buy a high-speed virtual server at an economical price from Radib, Click

After writing the main function, I need to include an example of how to use the function so that the user can easily use it. I also need to add explanations about the parameters and output of the function. Most importantly, I need to make sure that I use secure sources to generate random numbers. The secrets module in Python is more suitable for this purpose because it is more cryptographically secure. So it is better to use secrets instead of random. Finally, I test that the code works correctly and meets all the requirements. For example, I check that the password is the right length and has all the required character sets.

Here is a Python program to generate strong and unguessable passwords that follows modern security principles. Follow this tutorial from Radib:

import secrets
import string
from typing import List

def generate_strong_password(length: int = 16,
                            include_uppercase: bool = True,
                            include_lowercase: bool = True,
                            include_digits: bool = True,
                            include_symbols: bool = True,
                            exclude_similar: bool = True) -> str:
    """
    Function to generate strong passwords based on specified requirements.
    
    Parameters:
    length: Length of the password (recommended to be at least 12 characters).
    include_uppercase: Include uppercase letters.
    include_lowercase: Include lowercase letters.
    include_digits: Include digits.
    include_symbols: Include symbols.
    exclude_similar: Exclude similar characters like Il1O0.
    """
    
    # Define character sets
    characters = []
    uppercase = string.ascii_uppercase  # Uppercase English letters
    lowercase = string.ascii_lowercase  # Lowercase English letters
    digits = string.digits  # Digits from 0 to 9
    symbols = '!@#$%^&*()_+-=[]{}|;:,.<>?'  # Special symbols
    
    # Exclude similar characters if requested
    if exclude_similar:
        uppercase = uppercase.translate(str.maketrans('', '', 'IO'))  # Exclude I and O
        lowercase = lowercase.translate(str.maketrans('', '', 'l'))  # Exclude l
        digits = digits.translate(str.maketrans('', '', '01O'))  # Exclude 0, 1, and O
        symbols = symbols.translate(str.maketrans('', '', '|;<>'))  # Exclude some symbols
    
    # Collect required character sets
    if include_uppercase:
        characters.append(uppercase)
    if include_lowercase:
        characters.append(lowercase)
    if include_digits:
        characters.append(digits)
    if include_symbols:
        characters.append(symbols)
    
    # Ensure at least one character type is selected
    if not characters:
        raise ValueError("At least one character type must be selected")
    
    # Generate the password
    all_chars = ''.join(characters)  # Combine all selected characters
    password = []
    
    # Ensure at least one character from each selected type
    for charset in characters:
        password.append(secrets.choice(charset))
    
    # Complete the required password length
    for _ in range(length - len(characters)):
        password.append(secrets.choice(all_chars))
    
    # Shuffle the characters randomly
    secrets.SystemRandom().shuffle(password)
    
    return ''.join(password)

# Example usage:
if __name__ == "__main__":
    # Generate 5 passwords with a length of 20 characters
    print("Strong passwords:")
    for _ in range(5):
        password = generate_strong_password(length=20)
        print(f"• {password}")

    # Generate a password with a length of 16 characters without symbols
    simple_pass = generate_strong_password(include_symbols=False)
    print(f"\nPassword without symbols: {simple_pass}")

Security features of this algorithm:

Buy hourly cloud serverTo test your codes, click

1. Uses `secrets` module instead of `random` which is more suitable for security purposes
2. Generates 16-character passwords by default
3. Optionally removes similar characters (such as 1, l, and I)
4. Guarantees at least one character from each selected category
5. Advanced random combination using secure shuffle
6. Ability to fine-tune character types
7. Generating characters with uniform distribution

Advantages of this method over common algorithms:

- Resistant to brute-force attacks
- Prevent predictable patterns
- Remove base characters (to reduce input errors)
- Use a secure source for random numbers
- Flexibility in security settings

Recommendations for safe use:

1. Use a minimum length of 12 characters
2. Enable all character types
3. Do not reuse passwords generated in different services
4. Store passwords in a secure password manager
5. Update important passwords every 3-6 months