Generatore di password sicure da terminale

Come creare in Python un generatore di password casuali e sicure da riga di comando. Usa la libreria standard secrets e stima l'entropia.

Le password lunghe e generate casualmente sono la base per difendere i propri account, ma non tutti vogliono affidarsi a generatori web di terze parti. Se preferisci tenere tutto offline, o vuoi capire come funziona un algoritmo di generazione robusto, puoi costruire un generatore da terminale in Python con il modulo secrets.

In questa guida riproduco la logica del tool online generatore di password di ai riparo sul tuo computer: niente server esterni, niente telemetria, stima dell’entropia teorica in bit.

ℹ️ Nota / Prerequisito operativo
Serve Python 3 già installato. Percorso principale: Windows. I comandi per macOS e Linux sono scritti per intero sotto.
Se Python manca ancora: installazione Windows, macOS, Linux — letture opzionali solo se ti serve l’installazione.
Nessuna dipendenza pip: usi solo la libreria standard (secrets, argparse, math). Non serve un venv per questo script.

Scheda tecnica dello script

Concetto chiave: secrets, non random

In Python esiste il modulo random, ma la documentazione ufficiale è chiara: non va usato per sicurezza o crittografia. È pensato per simulazioni e, in molti casi, è prevedibile se un attaccante osserva abbastanza output.

Per le password serve un CSPRNG (Cryptographically Secure Pseudo-Random Number Generator). In Python usi secrets, che attinge all’entropia del sistema operativo (idea analoga a crypto.getRandomValues nel browser).

secrets.choice() estrae in modo uniforme dall’alfabeto: eviti scorciatoie “fai da te” sul modulo che renderebbero alcuni caratteri più probabili di altri. Lo script completo fa anche uno shuffle Fisher–Yates con secrets.randbelow, come il tool web.

Passaggio 1 — Apri il terminale e crea la cartella

Windows (principale)

1. Premi il tasto Windows, digita powershell (o cmd) e apri l’app.
2. Vai in Documenti e crea una cartella dedicata:

PowerShell:

cd $env:USERPROFILE\Documents
mkdir genera-password
cd genera-password

Prompt dei comandi:

cd %USERPROFILE%\Documents
mkdir genera-password
cd genera-password

macOS

1. Spotlight (Cmd + Spazio) → Terminale → Invio.
2. Comandi:

cd ~/Documents
mkdir genera-password
cd genera-password

Linux

1. Apri Terminale (su molte Ubuntu: Ctrl + Alt + T).
2. Comandi:

cd ~/Documents
mkdir genera-password
cd genera-password

Passaggio 2 — Scarica (o crea) lo script

Opzione A — download dal sito: salva genera_password.py dalla scheda download in cima a questa pagina nella cartella genera-password che hai appena creato. Controlla lo SHA-256 indicato in scheda (guida opzionale: verificare un download con SHA-256).

Opzione B — da GitHub: se preferisci il repository (README, licenza MIT, release), clona o scarica lo ZIP da github.com/lunoffice/generatore-password-terminale.

Windows (PowerShell), dalla cartella padre di genera-password (es. Documents):

git clone https://github.com/lunoffice/generatore-password-terminale.git genera-password
cd genera-password

macOS / Linux:

git clone https://github.com/lunoffice/generatore-password-terminale.git genera-password
cd genera-password

Se non hai git, nella pagina del repository usa Code → Download ZIP, estrai l’archivio e sposta/rinomina la cartella in genera-password. Il file utile è genera_password.py (stesso contenuto e stesso SHA-256 della scheda download). La release v1.0.0 espone anche il singolo file.

Opzione C — crea il file a mano

Windows (PowerShell), dalla cartella genera-password:

notepad genera_password.py

Incolla il codice completo del Passaggio 4, salva, chiudi Blocco note.

macOS / Linux:

nano genera_password.py

Incolla il codice, poi Ctrl+O, Invio, Ctrl+X per uscire da nano.

Passaggio 3 — Mini-prova: solo secrets.choice

Prima della CLI completa, il cuore del meccanismo in poche righe (utile per capire, non è ancora lo script scaricabile):

import secrets

alfabeto = (
    "abcdefghijklmnopqrstuvwxyz"
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789"
    "!@#$%^&*()-_=+[]{}|;:,.<>?/~"
)
password = "".join(secrets.choice(alfabeto) for _ in range(20))
print(password)

Se lo lanci tre volte, ottieni tre stringhe diverse. Limite: non garantisce almeno una maiuscola, un numero o un simbolo: per pura probabilità potresti ottenere solo minuscole. Per quello serve lo script completo.

Passaggio 4 — Script completo (parità col tool web)

Lo script scaricabile:

• sceglie lunghezza e set via argparse (ogni flag è spiegata nel Passaggio 5);
• esclude opzionalmente i caratteri ambigui (0, O, o, 1, l, I, |, `);
• garantisce almeno un carattere per ogni set attivo;
• mescola con Fisher–Yates + secrets;
• stima l’entropia teorica in bit (stesse soglie del tool online: Debole / Discreta / Buona / Molto forte).

Se hai già scaricato il file, salta l’incolla. Altrimenti usa questo codice (è quello del download):

#!/usr/bin/env python3
import argparse
import math
import secrets
import sys

LOWER = "abcdefghijklmnopqrstuvwxyz"
UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
DIGITS = "0123456789"
SYMBOLS = "!@#$%^&*()-_=+[]{}|;:,.<>?/~"
AMBIGUOUS = set("0Oo1lI|`")

def filter_ambiguous(charset, exclude):
    if not exclude:
        return charset
    return "".join(c for c in charset if c not in AMBIGUOUS)

def build_charset(use_lower, use_upper, use_digits, use_symbols, exclude_ambiguous):
    buckets = []
    def add(charset):
        filtered = filter_ambiguous(charset, exclude_ambiguous)
        if filtered:
            buckets.append(filtered)
    if use_lower:
        add(LOWER)
    if use_upper:
        add(UPPER)
    if use_digits:
        add(DIGITS)
    if use_symbols:
        add(SYMBOLS)
    pool = "".join(dict.fromkeys("".join(buckets)))
    return pool, buckets

def strength_label(bits):
    if bits < 40:
        return "Debole"
    if bits < 60:
        return "Discreta"
    if bits < 80:
        return "Buona"
    return "Molto forte"

def generate_password(length, use_lower, use_upper, use_digits, use_symbols, exclude_ambiguous):
    pool, buckets = build_charset(
        use_lower, use_upper, use_digits, use_symbols, exclude_ambiguous
    )
    if not pool or not buckets:
        raise ValueError("Devi selezionare almeno un set di caratteri.")
    if length < len(buckets):
        raise ValueError(f"Con questi set servono almeno {len(buckets)} caratteri.")
    chars = [secrets.choice(b) for b in buckets]
    for _ in range(length - len(buckets)):
        chars.append(secrets.choice(pool))
    for i in range(len(chars) - 1, 0, -1):
        j = secrets.randbelow(i + 1)
        chars[i], chars[j] = chars[j], chars[i]
    bits = length * math.log2(len(pool))
    return "".join(chars), bits, len(pool)

def main():
    parser = argparse.ArgumentParser(description="Generatore di password sicure da terminale")
    parser.add_argument("-n", "--length", type=int, default=20, help="Lunghezza (8-128, default: 20)")
    parser.add_argument("--no-lower", action="store_true", help="Escludi minuscole")
    parser.add_argument("--no-upper", action="store_true", help="Escludi maiuscole")
    parser.add_argument("--no-digits", action="store_true", help="Escludi numeri")
    parser.add_argument("--no-symbols", action="store_true", help="Escludi simboli")
    parser.add_argument(
        "--no-ambiguous",
        action="store_true",
        help="Escludi caratteri ambigui (0, O, o, 1, l, I, |, `)",
    )
    args = parser.parse_args()
    if args.length < 8 or args.length > 128:
        sys.exit("Errore: la lunghezza deve essere tra 8 e 128.")
    try:
        password, bits, alphabet_size = generate_password(
            args.length,
            not args.no_lower,
            not args.no_upper,
            not args.no_digits,
            not args.no_symbols,
            args.no_ambiguous,
        )
    except ValueError as exc:
        sys.exit(f"Errore: {exc}")
    print()
    print(f"Password : {password}")
    print(f"Lunghezza: {args.length} caratteri")
    print(f"Alfabeto : {alphabet_size} caratteri disponibili")
    print(f"Entropia : ~{int(bits)} bit ({strength_label(bits)})")
    print()

if __name__ == "__main__":
    main()

💡 Consiglio pratico — Errori utili
Se spegni tutti i set (--no-lower --no-upper --no-digits --no-symbols), lo script esce con un messaggio chiaro. Se chiedi 2 caratteri con 4 set attivi, ti dice quanti ne servono almeno: stessa logica del tool web.

Passaggio 5 — Esegui dal terminale

Resta nella cartella genera-password (dove c’è genera_password.py). Percorso principale: Windows; sotto ogni esempio utile trovi anche macOS/Linux.

5.1 — Verifica Python e prima generazione (default)

Windows:

python --version
python genera_password.py

Deve comparire qualcosa come Python 3.12.x. Se python non è riconosciuto, prova py genera_password.py oppure sistema il PATH (guida Windows opzionale in apertura).

macOS / Linux:

python3 --version
python3 genera_password.py

Cosa fa il default (nessuna opzione): lunghezza 20, set attivi = minuscole + maiuscole + numeri + simboli, caratteri ambigui inclusi. L’alfabeto completo conta 90 caratteri disponibili.

Output atteso (la password cambia ogni volta):

Password : …stringa di 20 caratteri…
Lunghezza: 20 caratteri
Alfabeto : 90 caratteri disponibili
Entropia : ~… bit (Molto forte)

5.2 — Elenco opzioni: python genera_password.py -h

Per non indovinare i nomi delle flag, chiedi aiuto allo script stesso.

Windows:

python genera_password.py -h

macOS / Linux:

python3 genera_password.py -h

(Equivale a --help.) Compare la descrizione di ogni argomento. Le flag sotto sono quelle dello script scaricabile.

5.3 — Guida flag per flag

Le opzioni --no-… sono interruttori: se le scrivi, spegni quel set. Se non le scrivi, quel set resta attivo (default). Non esistono --lower / --upper “positivi”: il default è già “tutto acceso”.

-n / --length — lunghezza

Stesso effetto: -n 24 oppure --length 24. Non scrivere --lengh (typo tipico): la flag corretta è --length.

Windows — 16 caratteri (default set):

python genera_password.py --length 16
python genera_password.py -n 16

Windows — minimo e massimo ammessi:

python genera_password.py --length 8
python genera_password.py --length 128

Windows — fuori range (deve fallire):

python genera_password.py --length 7

Messaggio atteso: lunghezza tra 8 e 128.

macOS / Linux: stessi numeri con python3:

python3 genera_password.py --length 16
python3 genera_password.py -n 32

--no-lower — senza minuscole

Windows:

python genera_password.py --no-lower

Restano maiuscole, numeri e simboli (salvo altre --no-…).

macOS / Linux:

python3 genera_password.py --no-lower

--no-upper — senza maiuscole

Windows:

python genera_password.py --no-upper

macOS / Linux:

python3 genera_password.py --no-upper

--no-digits — senza numeri

Windows:

python genera_password.py --no-digits

macOS / Linux:

python3 genera_password.py --no-digits

--no-symbols — senza simboli

Utile se un sito rifiuta caratteri speciali (o ne accetta pochi).

Windows:

python genera_password.py --no-symbols

Alfabeto tipico: 62 caratteri (26+26+10), se gli ambigui restano inclusi.

macOS / Linux:

python3 genera_password.py --no-symbols

--no-ambiguous — senza caratteri ambigui

Non spegne un “set” intero: filtra 0 O o 1 l I | e il backtick dentro i set ancora attivi. Con tutti i set attivi l’alfabeto passa da 90 a circa 83 caratteri.

Windows:

python genera_password.py --no-ambiguous

macOS / Linux:

python3 genera_password.py --no-ambiguous

5.4 — Combinazioni tipiche (una per volta)

Puoi accumulare più flag nello stesso comando. L’ordine non conta.

1) Password “da digitare a mano” (più lunga, niente simboli, niente ambigui)

Windows:

python genera_password.py --length 24 --no-symbols --no-ambiguous

macOS / Linux:

python3 genera_password.py --length 24 --no-symbols --no-ambiguous

Alfabeto tipico: 56 caratteri (lettere + cifre senza ambigui).

2) Solo lettere e numeri, 20 caratteri (simboli off)

Windows:

python genera_password.py --length 20 --no-symbols

macOS / Linux:

python3 genera_password.py --length 20 --no-symbols

3) Solo minuscole e numeri (niente maiuscole, niente simboli)

Windows:

python genera_password.py --length 20 --no-upper --no-symbols

macOS / Linux:

python3 genera_password.py --length 20 --no-upper --no-symbols

4) Solo maiuscole + simboli (niente minuscole, niente cifre) — caso raro

Windows:

python genera_password.py --length 20 --no-lower --no-digits

macOS / Linux:

python3 genera_password.py --length 20 --no-lower --no-digits

5) Errore voluto: spegni tutti i set

Windows:

python genera_password.py --no-lower --no-upper --no-digits --no-symbols

macOS / Linux:

python3 genera_password.py --no-lower --no-upper --no-digits --no-symbols

Messaggio atteso: devi selezionare almeno un set. Stessa logica del tool web.

6) Aiuto rapido se dimentichi una flag

Windows:

python genera_password.py -h

macOS / Linux:

python3 genera_password.py -h

Lì ritrovi i nomi esatti (--length, non --lengh) e il range 8–128.

💡 Consiglio pratico — Due comandi da usare subito
Se non vuoi scegliere le flag una per una, parti da qui. Poi salva subito la stringa nel password manager (non in un file di testo).

1) Più sicura (consigliata per email, banca, vault) — 24 caratteri, tutti i set attivi (minuscole, maiuscole, numeri, simboli):

Windows:

python genera_password.py --length 24

macOS / Linux:

python3 genera_password.py --length 24

2) Variante “accettata da quasi tutti i siti” — stessa lunghezza, senza simboli (molti form rifiutano !@#… o ne accettano pochi):

Windows:

python genera_password.py --length 24 --no-symbols

macOS / Linux:

python3 genera_password.py --length 24 --no-symbols

Se digiti o leggi la password a voce, aggiungi --no-ambiguous a uno dei due comandi. Non spegnere troppi set “per comodità”: riduci l’alfabeto e quindi i bit di entropia.

🚨 Avviso critico — Clipboard
Questo script non copia negli appunti (niente pyperclip). Su Windows e Mac la cronologia appunti / Universal Clipboard può sincronizzare segreti sul cloud. Stampa a schermo, copia tu nel password manager, poi chiudi la finestra del terminale.

Dopo la generazione: dove finisce la password

Livello di rischio read-only: calcola e stampa. Non scrive su disco e non usa la rete.

Non salvare la stringa dentro lo script né in un .txt in chiaro. Incollala in un password manager (es. il flusso della guida pratica al password manager — lettura opzionale).

L’entropia stimata (es. ~118 bit) misura lo spazio delle combinazioni sull’alfabeto scelto. Non ti protegge da phishing o da un database rubato se riusi la stessa password altrove. Per capire se un account è già in una fuga dati, la lettura opzionale è come sapere se email o password sono compromesse.

Domande Frequenti (FAQ)

random.choice() basta per le password?

No. Usa sempre secrets.choice() (o API equivalenti CSPRNG).

Quanti caratteri per un account importante?

Nella pratica consiglio almeno 16–20 caratteri per email principale, banca e master del password manager, con più set attivi. Non è una soglia magica: lunghezza + alfabeto + unicità contano insieme.

Cosa sono i bit di entropia?

Stima: lunghezza × log₂(dimensione alfabeto). Orientano sulle opzioni; non certificano invulnerabilità.

Questo script sostituisce il password manager?

No. Genera la stringa; il manager la conserva e la compila.

Che differenza c’è con Diceware?

Qui ottieni una stringa densa di caratteri casuali (ideale da far gestire al manager). Diceware usa parole memorizzabili: utile soprattutto per la master password che vuoi ricordare a memoria (pezzo a parte in programma).

Posso scaricare lo script anche da GitHub?

Sì. Il repository pubblico è lunoffice/generatore-password-terminale: contiene genera_password.py, README, licenza MIT e la release v1.0.0. Il contenuto dello script coincide con il download della scheda in cima a questa pagina (stesso SHA-256). Puoi clonare con git, scaricare lo ZIP oppure usare il pulsante GitHub nella scheda download.

Come uso --length, -n e le flag --no-…?

--length (o -n) imposta i caratteri, da 8 a 128 (default 20). Ogni --no-lower, --no-upper, --no-digits, --no-symbols spegne quel set; --no-ambiguous toglie solo i caratteri confondibili. Puoi combinarle, es. python genera_password.py --length 24 --no-symbols --no-ambiguous (su Mac/Linux usa python3). Per l’elenco completo: python genera_password.py -h.

Se qualcosa non funziona

• python / python3 non riconosciuto → PATH o installazione incompleta; riparti dalle guide OS.
• Errore: Devi selezionare almeno un set → hai disattivato tutti i set; togli almeno un --no-… tra lower/upper/digits/symbols.
• la lunghezza deve essere tra 8 e 128 → correggi --length / -n (es. non usare 7 o 200).
• Servono almeno N caratteri → alza --length o riduci i set attivi (casi limite se i set filtrati restano molti rispetto alla lunghezza).
• Flag sconosciuta / typo → controlla lo spelling (--length, non --lengh); lancia -h.
• La password non compare → assicurati di essere nella cartella giusta (dir / ls deve elencare genera_password.py).