Generare password nel terminale: cosa funziona e cosa fallisce senza avvisare

Pubblicato il di David Carrero

A maggio è uscito su Medium un tutorial con un titolo difficile da ignorare: Generate Unbreakable Passwords in Your Terminal Using Pure Bash. L’idea di fondo è buona e la condividiamo: il terminale ha già un ottimo generatore di password, non c’è niente da installare e la password non esce dalla tua macchina. È la stessa cosa che questo sito sostiene con il generatore nel browser, solo senza browser.

Così abbiamo copiato i suoi comandi e li abbiamo eseguiti su un Mac, il 10 novembre 2026, con macOS 27.2 e le impostazioni internazionali in spagnolo. E su un Linux, per confronto. Quello che funziona funziona molto bene. Quello che fallisce, in diversi casi, fallisce senza dire niente, che è la cosa peggiore che possa capitare a un generatore di password.

Da dove viene la casualità

Il tutorial si apre con quello che conta davvero: openssl rand -base64 32 ti dà 32 byte casuali codificati in base64, e /dev/urandom è la fonte da cui attingono quasi tutti gli altri comandi.

Una precisazione, perché il tutorial racconta la cosa in modo un po’ più romantico di quanto sia. Né openssl rand né /dev/urandom ti consegnano «pura casualità fisica»: sono entrambi un generatore crittografico, un CSPRNG, che il sistema operativo inizializza con rumore reale dell’hardware e che da lì in poi produce byte che nessuno può prevedere. OpenSSL lo scrive nella sua documentazione: è un generatore deterministico del modello NIST SP 800-90A che si inizializza e si reinizializza da solo a partire dal sistema. Linux ne usa uno basato su ChaCha20; macOS, secondo la guida alla sicurezza di Apple, uno derivato da Fortuna.

Non è un difetto, è il motivo per cui funziona: un CSPRNG ben inizializzato è esattamente quello che serve. È lo stesso tipo di fonte di crypto.getRandomValues(), quella che usa il generatore di questo sito.

E c’è un altro merito di cui il tutorial non si vanta, e dovrebbe: il trucco di tr -dc, tenere solo i byte che cadono dentro l’alfabeto e buttare il resto, non introduce distorsioni. È il modo corretto. Quello ingenuo, prendere il byte e calcolare il resto della divisione per la dimensione dell’alfabeto, favorisce alcuni caratteri rispetto ad altri; scartare no.

Su un Mac, il comando restituisce una lettera

Questo è il comando del tutorial per una password di lettere e numeri:

cat /dev/urandom | tr -dc 'a-zA-Z0-9' | head -c 32

Sul Mac, con le impostazioni internazionali in spagnolo, esce questo:

tr: Illegal byte sequence

E sotto, una E. Una sola lettera. Il codice di uscita è 0: per il terminale, l’operazione è andata a buon fine.

La causa è che il tr di macOS legge l’input come testo nella codifica delle tue impostazioni internazionali, UTF-8, e i byte casuali non formano quasi mai UTF-8 valido. Appena trova il primo che non torna, si ferma. Quello che aveva filtrato fino a quel momento, a volte niente, a volte un paio di caratteri, è ciò che arriva a head, e head non ha modo di sapere che ne aspettava 32.

Su Linux non succede: il tr di GNU lavora per byte e ignora le impostazioni internazionali. L’abbiamo provato in un container Debian e sono usciti tutti e 32 i caratteri. Per questo un tutorial scritto e provato su Linux può andare benissimo per chi l’ha scritto e rompersi sul Mac di chi lo legge.

La correzione è una variabile davanti: LC_ALL=C tr -dc …, che dice a tr di trattare l’input come byte. Ma l’importante non è la correzione, è la forma del guasto. La funzione genpass proposta dal tutorial, messa nel .bashrc di un Mac, stampa quella E come se fosse una password. Se la incolli a occhi chiusi in un campo senza lunghezza minima, è già la tua password.

Il trattino che non era un trattino

Per la versione «con simboli», il tutorial usa questo alfabeto:

tr -dc 'a-zA-Z0-9!@#$%^&*()_+-=[]{}'

L’intenzione è chiara: lettere, cifre e diciotto simboli. Ma per tr un trattino fra due caratteri è un intervallo, proprio come in a-z. Quindi +-= non significa «più, trattino, uguale»: significa tutto quello che c’è fra + e = nella tabella ASCII, che comprende la virgola, il punto, la barra, le dieci cifre, i due punti, il punto e virgola e il segno di minore.

L’abbiamo misurato generando due milioni di byte e tenendo i caratteri distinti che uscivano: 86, non gli 80 previsti. Uguale su macOS e su Linux. Non è un problema di sicurezza, sei caratteri in più danno un po’ più di entropia, non meno; il problema è non sapere cosa stai generando. Se il sistema in cui va la password rifiuta il ; o il <, il comando fallisce ogni tanto e non c’è modo di indovinare perché. La regola è mettere il trattino alla fine dell’insieme, dove tr lo legge come trattino.

E lo diciamo con umiltà, perché scrivendo la versione corretta qui sotto siamo caduti in una trappola della stessa famiglia: avevamo messo l’alfabeto come valore predefinito di un parametro, ${2:-…{}-}, e la prima parentesi graffa di chiusura dell’alfabeto chiudeva il parametro. Il risultato generava una | che nessuno aveva chiesto e aveva perso il trattino. Ce ne siamo accorti solo perché abbiamo contato i caratteri che uscivano.

64 caratteri che a volte sono 58

La modalità predefinita della funzione fa questo:

openssl rand -base64 48 | tr -dc 'a-zA-Z0-9' | head -c "$LENGTH"

48 byte in base64 fanno 64 caratteri. Ma base64 include + e /, e il filtro li butta via, quindi quello che resta è un po’ meno di 64. Per i 32 della lunghezza predefinita basta e avanza. Per genpass 64, no: l’abbiamo eseguito 200 volte e solo 28 sono usciti con 64 caratteri; gli altri, fra 58 e 63. Senza avviso.

La modalità esadecimale ha la sua versione dello stesso problema: divide la lunghezza per due per calcolare i byte, così genpass 15 hex ne restituisce 14.

Il valutatore che applaude P@ssw0rd

Il tutorial si chiude con uno script che dà un punteggio alle password: punti per la lunghezza, uno per le minuscole, uno per le maiuscole, uno per le cifre e due per i simboli. L’abbiamo provato con qualcuna:

  • P@ssw0rd — STRONG
  • Estate2026! — STRONG
  • correct-horse-battery-staple — STRONG
  • 35 volte la lettera a — MODERATE

P@ssw0rd prende lo stesso voto di quattro parole a caso. È fra le prime che prova qualsiasi dizionario d’attacco. Lo script non può saperlo perché non guarda cosa la password è, solo di che tipi di caratteri è fatta. È esattamente la regola «una maiuscola, un numero e un simbolo» che il NIST ha smesso di raccomandare nel 2017, e di cui abbiamo già parlato nel gioco delle password.

C’è un secondo problema, più pratico: lo script riceve la password come argomento, ./scorepass.sh "P@ssw0rd". Così resta scritta nella cronologia della tua shell, in ~/.zsh_history o ~/.bash_history, e, mentre gira, è visibile a qualsiasi altro utente della macchina che elenchi i processi. Per provare una password vera, il controllo di questo sito guarda schemi, dizionari e sostituzioni come @ al posto di a, e lo fa nel tuo browser senza inviare niente.

Quanto basta

Il tutorial presenta i 256 bit di openssl rand -base64 32 come «la stessa robustezza che protegge le transazioni bancarie». Il numero è giusto e il paragone è di troppo: 256 bit sono molto più di quanto serva a una password. Con il modello di attacco del resto del sito, 10¹² tentativi al secondo, offline e con hash veloce, 128 bit arrivano già a 10¹⁹ anni. Usarne 256 non fa male, ma non bisogna confondere «di più» con «necessario». Lo spieghiamo con calma in quanto ci mette una password a cadere.

Due dettagli sui formati, che non riguardano la sicurezza ma l’uso:

  • base64 non è sicuro per gli URL, anche se il tutorial lo dice: include +, / e l’= finale. Quell’= è riempimento, non casualità; i 256 bit viaggiano nei 43 caratteri davanti. Esiste una variante, base64url, che sostituisce + e / con - e _, ma openssl rand -base64 non la usa.
  • L’esadecimale dà 4 bit per carattere, la metà di un alfabeto di lettere, cifre e simboli. openssl rand -hex 32 produce 64 caratteri e 256 bit: perfetto per una chiave API. Ma genpass 16 hex dà 16 caratteri e 64 bit, che con lo stesso modello di attacco cadono in media in circa 107 giorni. Sembra lunga; non lo è poi così tanto.

Le parole, e un esempio che non è uscito da nessun comando

La modalità words pesca parole da /usr/share/dict/words con shuf. Su un Mac shuf non esiste: è di GNU e macOS non lo include, quindi quella modalità semplicemente non funziona. La lista invece c’è, e ha 235.976 parole, che con quattro darebbero circa 71 bit. Tanti. Il problema è che buona parte sono parole che non hai mai visto, e il bello di una frase di parole è poterla ricordare.

L’esempio di output che mostra il tutorial, correct-horse-battery-staple, non l’ha generato nessun comando: è la frase della striscia 936 di XKCD, del 2011. Quella striscia ha ragione in quello che dice, quattro parole scelte a caso battono una parola con sostituzioni, ma il tutorial la riassume come «la lunghezza batte sempre la complessità», e non è quello che dice. A vincere è il numero di opzioni fra cui si è scelto a caso. Trentacinque «a» hanno lunghezza da vendere e zero entropia. Se vuoi frasi di parole fatte bene, Diceware usa una lista di 7.776 parole pensate per essere ricordate, a 12,9 bit ciascuna.

Una versione che fallisce ad alta voce

Questo è quello che proponiamo. Prima di pubblicarla l’abbiamo provata in bash e in zsh su macOS, e in bash su Linux:

genpass() {
  local n="${1:-20}" set='A-Za-z0-9!@#%^&*()_+=-' pw
  [ -n "$2" ] && set="$2"
  pw=$(LC_ALL=C tr -dc "$set" < /dev/urandom | head -c "$n")
  [ "${#pw}" -eq "$n" ] || { echo "genpass: non riuscito" >&2; return 1; }
  printf '%s\n' "$pw"
}

Tre scelte, ognuna per uno dei guasti visti sopra:

  • LC_ALL=C davanti a tr, perché su un Mac legga byte e non si fermi.
  • Il trattino alla fine dell’alfabeto, perché sia un trattino. L’abbiamo verificato contando: escono esattamente i 75 caratteri scritti, non uno di più.
  • Il controllo della lunghezza. Se per qualche motivo esce una password più corta di quella richiesta, la funzione non la stampa, avvisa sull’uscita degli errori e restituisce un codice diverso da 0. Che un generatore fallisca va bene. Che fallisca e consegni comunque qualcosa è ciò che non deve succedere.

genpass dà 20 caratteri di quell’alfabeto, circa 124 bit. genpass 32 ne dà 32. genpass 6 0-9 dà un PIN. L’alfabeto lascia fuori apposta $, l’apice inverso e le virgolette: sono i caratteri che una shell o un file di configurazione interpretano, e una password che si rompe quando la incolli in un .env non è più sicura, è più scomoda.

Quello che il tutorial azzecca alla fine

L’ultima sezione del tutorial è la migliore: generare è facile, il difficile è non riusare. Una password da 256 bit usata su due siti è compromessa su entrambi il giorno in cui uno dei due subisce una fuga di dati. La sua proposta, generare nel terminale e salvare in un gestore come Bitwarden o KeePass, è esattamente l’unica regola sopravvissuta.

Un ultimo avvertimento sull’altro suggerimento, copiare negli appunti con pbcopy o xclip. È meglio che stamparla a schermo, ma gli appunti non sono un posto privato: i gestori degli appunti tengono una cronologia, e su un Mac con Handoff attivo quello che copi può comparire anche sul tuo iPhone. Copia, incolla e copia qualcos’altro sopra.


Fonti: il tutorial «Generate Unbreakable Passwords in Your Terminal Using Pure Bash», pubblicato su Medium il 12 maggio 2026 · tutti i comandi sono stati eseguiti il 10 novembre 2026 su macOS 27.2 (bash 3.2, zsh, il tr di sistema, OpenSSL 4.1) e in un container Debian stabile con GNU coreutils 9.7 · documentazione di OpenSSL, RAND(7): generatore deterministico secondo NIST SP 800-90A Rev. 1, inizializzato dal sistema operativo · pagina di manuale random(4) di Linux · Apple, Apple Platform Security, generazione di numeri casuali · XKCD 936, «Password Strength» (2011) · NIST SP 800-63B (2017) sulle regole di composizione · il modello di attacco, 10¹² tentativi al secondo offline con hash veloce, è lo stesso del resto del sito.

Foto di Luis Gomes · Pexels

← Torna al blog