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— STRONGEstate2026!— STRONGcorrect-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_, maopenssl rand -base64non la usa. - L’esadecimale dà 4 bit per carattere, la metà di un alfabeto di lettere,
cifre e simboli.
openssl rand -hex 32produce 64 caratteri e 256 bit: perfetto per una chiave API. Magenpass 16 hexdà 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=Cdavanti atr, 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