Generating Secure Passwords in Python

Password security is essential for protecting personal and corporate data. In Python, generating secure passwords must involve cryptographically reliable tools. The secrets module allows you to create random, robust passwords resistant to predictive attacks, ensuring sufficient entropy and adherence to security best practices.

🔗 Do you like Techelopment? Check out the website for all the details!

The Correct Principle

A secure password must:

Use cryptographic entropy
Include uppercase letters, lowercase letters, numbers, and symbols
Have sufficient length (≥ 16 characters)
Avoid predictable patterns

In Python, this is achieved using secrets + string.

Most Secure Method (Recommended)


import secrets
import string

def generate_password(length=16):
    alphabet = string.ascii_letters + string.digits + string.punctuation
    return ''.join(secrets.choice(alphabet) for _ in range(length))

password = generate_password(20)
print(password)

This method uses the secrets module, designed to provide cryptographically secure random numbers.

By combining secrets.choice() with a broad set of characters—letters, numbers, and symbols—you obtain a password resistant to brute force and predictive attacks.

This approach satisfies security best practices and ensures sufficient entropy, making passwords difficult to guess even with advanced attacks.

🔎 Why it is secure

secrets.choice() uses os.urandom
Resistant to:

brute force
predictive attacks

Compliant with OWASP best practices

Even More Robust Version (Category Guarantee)


def generate_strong_password(length=20):
    if length < 12:
        raise ValueError("Minimum recommended length: 12")

    chars = {
        'upper': string.ascii_uppercase,
        'lower': string.ascii_lowercase,
        'digit': string.digits,
        'symbol': string.punctuation
    }

    password = [
        secrets.choice(chars['upper']),
        secrets.choice(chars['lower']),
        secrets.choice(chars['digit']),
        secrets.choice(chars['symbol']),
    ]

    alphabet = ''.join(chars.values())
    password += [secrets.choice(alphabet) for _ in range(length - 4)]

    secrets.SystemRandom().shuffle(password)
    return ''.join(password)

password = generate_strong_password()
print(password)

This enhancement combines the secrets module with a controlled selection of characters to ensure security and complexity.

First, character categories are defined: uppercase letters, lowercase letters, numbers, and symbols. To ensure the password contains at least one character from each category, at least one element is selected from each set.

Next, the remaining characters are filled by randomly choosing from the entire combined alphabet.

Finally, the SystemRandom().shuffle() function mixes the characters to eliminate predictable patterns, increasing entropy.

This approach guarantees long, complex, and cryptographically secure passwords, resistant to brute force and predictive attacks. Using secrets makes the generator safe even in professional or corporate contexts, following the best practices recommended by OWASP.

💪 Why it is more robust:

Inclusion of all categories: uppercase, lowercase, numbers, symbols
Minimum recommended length ≥ 12-16 characters
Character shuffling with SystemRandom().shuffle()
Maximum resistance to brute force and predictive attacks

What NOT to use

random.choice()   # ❌ non-cryptographic
uuid.uuid4()      # ❌ predictable
hash()            # ❌ not a generator

💡 Remember

The most secure technique is:

secrets.choice() with a broad alphabet and length ≥ 16.

Follow me #techelopment

Official site: www.techelopment.it
facebook: Techelopment
instagram: @techelopment
X: techelopment
Bluesky: @techelopment
telegram: @techelopment_channel
whatsapp: Techelopment
youtube: @techelopment

Techelopment

Cerca nel blog