 |
La sicurezza delle password è fondamentale per proteggere dati personali e aziendali. In Python, la generazione di password sicure deve usare strumenti crittograficamente affidabili. Il modulo secrets permette di creare password casuali, robuste e resistenti ad attacchi predittivi, garantendo entropia sufficiente e rispetto delle migliori pratiche di sicurezza.
🔗 Ti piace Techelopment? Dai un'occhiata al sito per tutti i dettagli!
Principio corretto
Una password sicura deve:
- Usare entropia crittografica
- Includere lettere maiuscole, minuscole, numeri e simboli
- Avere lunghezza sufficiente (≥ 16 caratteri)
- Evitare pattern prevedibili
In Python questo si ottiene con secrets + string.
Metodo più sicuro (raccomandato)
import secrets
import string
def genera_password(lunghezza=16):
alfabeto = string.ascii_letters + string.digits + string.punctuation
return ''.join(secrets.choice(alfabeto) for _ in range(lunghezza))
password = genera_password(20)
print(password)
Questo metodo utilizza il modulo
secrets, progettato per fornire numeri casuali crittograficamente sicuri. Combinando
secrets.choice() con un insieme ampio di caratteri—lettere, numeri e simboli—si ottiene una password resistente a brute force e attacchi predittivi. Questo approccio soddisfa le best practice di sicurezza e garantisce entropia sufficiente, rendendo le password difficili da indovinare anche con attacchi avanzati.
🔎 Perché è sicuro
secrets.choice()usaos.urandom- Resistente a:
- brute force
- attacchi predittivi
- Conforme alle best practice OWASP
Versione ancora più robusta (garanzia di categorie)
def genera_password_forte(lunghezza=20):
if lunghezza < 12:
raise ValueError("Lunghezza minima consigliata: 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']),
]
alfabeto = ''.join(chars.values())
password += [secrets.choice(alfabeto) for _ in range(lunghezza - 4)]
secrets.SystemRandom().shuffle(password)
return ''.join(password)
password = genera_password_forte()
print(password)
Questo miglioramento combina il modulo
secrets con una selezione controllata di caratteri per garantire sicurezza e complessità. Innanzitutto, si definiscono categorie di caratteri: lettere maiuscole, lettere minuscole, numeri e simboli. Per assicurare che la password contenga almeno un carattere per ciascuna categoria, si seleziona almeno un elemento da ogni insieme.
Successivamente, si completano i restanti caratteri scegliendo casualmente dall’intero alfabeto combinato.
Infine, la funzione
SystemRandom().shuffle() mischia i caratteri per eliminare schemi prevedibili, aumentando l’entropia. Questo approccio garantisce password lunghe, complesse e crittograficamente sicure, resistenti a attacchi di forza bruta e predittivi. L’uso di
secrets rende il generatore sicuro anche in contesti professionali o aziendali, rispettando le best practice raccomandate da OWASP.💪 Perchè è più robusto:
- Inclusione di tutte le categorie: maiuscole, minuscole, numeri, simboli
- Lunghezza minima consigliata ≥ 12-16 caratteri
- Mescolamento dei caratteri con
SystemRandom().shuffle() - Massima resistenza a brute force e attacchi preditti
Cosa non usare
random.choice() # ❌ non crittografico
uuid.uuid4() # ❌ prevedibile
hash() # ❌ non è un generatore
💡 Ricorda
La tecnica più sicura è:
secrets.choice() con un alfabeto ampio e lunghezza ≥ 16.
Follow me #techelopment
Official site: www.techelopment.it
facebook: Techelopment
instagram: @techelopment
X: techelopment
Bluesky: @techelopment
telegram: @techelopment_channel
whatsapp: Techelopment
youtube: @techelopment
