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

> Il terminale è un buon generatore di password e non serve installare niente. Ma abbiamo provato su un Mac i comandi di un tutorial molto completo e metà fallivano: uno restituiva una sola lettera senza dare errore. Cosa succede, perché, e una versione che fallisce ad alta voce.

2026-11-10 · David Carrero · password.es
Original: https://password.es/it/blog/generare-password-nel-terminale/

---

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](/it/blog/perche-non-inviamo-la-tua-password/), 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](/it/).

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](/it/blog/il-gioco-delle-password-e-le-regole-che-non-proteggono/).

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](/it/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](/it/blog/quanto-ci-mette-davvero-la-tua-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](/it/blog/cosa-sono-i-bit-di-entropia/), 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](/it/blog/diceware-dadi-password-migliore/) 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:

```bash
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](/it/blog/il-tuo-gestore-contro-la-tua-memoria/).

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.*
