# Generar contrasenyes al terminal: el que funciona i el que falla sense avisar

> El terminal és un bon generador de contrasenyes i no cal instal·lar res. Però vam provar en un Mac les ordres d'un tutorial molt complet i la meitat fallaven: una retornava una sola lletra sense donar cap error. Què passa, per què, i una versió que falla en veu alta.

2026-11-10 · David Carrero · password.es
Original: https://password.es/ca/blog/generar-contrasenyes-al-terminal/

---

Al maig es va publicar a Medium un tutorial amb un títol difícil d'ignorar:
*Generate Unbreakable Passwords in Your Terminal Using Pure Bash*. La idea de
fons és bona i la compartim: **el terminal ja porta un generador de contrasenyes
excel·lent**, no cal instal·lar res i la contrasenya no surt de la teva
màquina. És el mateix que defensa aquest lloc amb [el generador del
navegador](/ca/blog/per-que-no-enviem-la-teva-contrasenya/), només que sense
navegador.

Així que vam copiar les seves ordres i les vam executar en un Mac, el 10 de
novembre de 2026, amb macOS 27.2 i la configuració regional en castellà. I en un
Linux, per comparar. El que funciona, funciona molt bé. El que falla, en
diversos casos, falla sense dir res, que és el pitjor que li pot passar a un
generador de contrasenyes.

## D'on surt l'atzar

El tutorial obre amb el que de debò importa: `openssl rand -base64 32` et dona
32 bytes aleatoris codificats en base64, i `/dev/urandom` és la font de què
beuen gairebé totes les altres ordres.

Un matís, perquè el tutorial ho explica una mica més romàntic del que és. Ni
`openssl rand` ni `/dev/urandom` et lliuren «aleatorietat física pura»: tots
dos són un generador criptogràfic —un CSPRNG— que el sistema operatiu sembra amb
soroll real del maquinari i que a partir d'aquí produeix bytes que ningú no pot
predir. OpenSSL ho diu a la seva documentació: és un generador determinista del
model NIST SP 800-90A que se sembra i es resembra tot sol des del sistema.
Linux en fa servir un basat en ChaCha20; macOS, segons la guia de seguretat
d'Apple, un derivat de Fortuna.

No és cap pega, és el motiu pel qual funciona: un CSPRNG ben sembrat és
exactament el que vols. És la mateixa mena de font que
`crypto.getRandomValues()`, la que fa servir el [generador d'aquest lloc](/ca/).

I hi ha un altre encert del qual el tutorial no presumeix, i n'hauria de presumir: el
truc de `tr -dc` —quedar-se només amb els bytes que cauen dins de l'alfabet i
llençar la resta— **no introdueix biaix**. És el correcte. La manera ingènua,
agafar el byte i fer el residu de dividir-lo per la mida de l'alfabet, afavoreix
uns caràcters per sobre d'uns altres; descartar, no.

## En un Mac, l'ordre retorna una lletra

Aquesta és l'ordre del tutorial per a una contrasenya de lletres i números:

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

Al Mac, amb la configuració regional en castellà, el que surt és això:

`tr: Illegal byte sequence`

I a sota, una `E`. Una sola lletra. **El codi de sortida és 0**: per al
terminal, l'operació ha anat bé.

La causa és que el `tr` de macOS llegeix l'entrada com a text en la codificació
de la teva configuració regional, UTF-8, i els bytes aleatoris gairebé mai no
formen UTF-8 vàlid. Tan bon punt en troba el primer que no encaixa, s'atura. El
que havia filtrat fins aleshores —de vegades res, de vegades un parell de
caràcters— és el que arriba a `head`, i `head` no té manera de saber que
n'esperava 32.

A Linux no passa: el `tr` de GNU treballa per bytes i no mira la configuració
regional. Ho vam provar en un contenidor Debian i van sortir els 32 caràcters.
Per això un tutorial escrit i provat a Linux pot estar perfectament bé per a qui
el va escriure i trencar-se al Mac de qui el llegeix.

La solució és una variable al davant: `LC_ALL=C tr -dc …`, que diu a `tr`
que tracti l'entrada com a bytes. Però l'important no és la solució, és la
forma de la fallada. La funció `genpass` que proposa el tutorial, posada al
`.bashrc` d'un Mac, imprimeix aquesta `E` com si fos una contrasenya. Si
l'enganxes sense fixar-t'hi en un camp que no exigeix una longitud mínima,
aquesta passa a ser la teva contrasenya.

## El guionet que no era un guionet

Per a la versió «amb símbols», el tutorial fa servir aquest alfabet:

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

La intenció és clara: lletres, xifres i divuit símbols. Però per a `tr`, un
guionet entre dos caràcters és un interval, igual que a `a-z`. Així que `+-=` no
vol dir «més, guionet, igual»: vol dir **tot el que hi ha entre `+` i `=` a la
taula ASCII**, que inclou la coma, el punt, la barra, les deu xifres, els dos
punts, el punt i coma i el signe de menor que.

Ho vam mesurar generant dos milions de bytes i quedant-nos amb els caràcters
diferents que van sortir: 86, no els 80 que es pretenien. Igual a macOS que a
Linux. No és un problema de seguretat —sis caràcters més donen una mica més
d'entropia, no pas menys—, el problema és no saber què estàs generant. Si el
sistema on va la contrasenya rebutja el `;` o el `<`, l'ordre falla de tant en
tant i no hi ha manera d'endevinar per què. La regla és posar el guionet al
final del conjunt, on `tr` el llegeix com a guionet.

I ho expliquem amb humilitat, perquè en escriure la versió corregida de més
avall vam caure en un parany de la mateixa família: vam posar l'alfabet com a
valor per defecte d'un paràmetre, `${2:-…{}-}`, i la primera clau de tancament
de l'alfabet tancava el paràmetre. El resultat generava una `|` que ningú no
havia demanat i havia perdut el guionet. Només ho vam veure perquè vam comptar
els caràcters que sortien.

## 64 caràcters que de vegades són 58

El mode per defecte de la funció fa això:

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

48 bytes en base64 són 64 caràcters. Però base64 inclou `+` i `/`, i el filtre
els llença, de manera que el que queda és una mica menys de 64. Per als 32 de
la longitud per defecte, n'hi ha de sobres. Per a `genpass 64`, no: el vam
executar 200 vegades i **només 28 van sortir amb 64 caràcters**; la resta,
entre 58 i 63. Sense avís.

El mode hexadecimal té la seva pròpia versió del mateix problema: divideix la
longitud entre dos per calcular els bytes, així que `genpass 15 hex` en retorna
14.

## L'avaluador que aplaudeix P@ssw0rd

El tutorial acaba amb un script que puntua contrasenyes: punts per la longitud,
un per tenir minúscules, un altre per majúscules, un altre per xifres i dos per
símbols. El vam executar amb unes quantes:

- `P@ssw0rd` — **STRONG**
- `Estiu2026!` — **STRONG**
- `correct-horse-battery-staple` — **STRONG**
- 35 vegades la lletra `a` — MODERATE

`P@ssw0rd` surt amb la mateixa nota que quatre paraules a l'atzar. És de les
primeres que prova qualsevol diccionari d'atac. L'script no ho pot saber perquè
no mira què *és* la contrasenya, només de quins tipus de caràcters està feta. És
exactament la regla d'«una majúscula, un número i un símbol» que el NIST va
deixar de recomanar el 2017, i de la qual ja vam parlar a [el joc de les
contrasenyes](/ca/blog/el-joc-de-les-contrasenyes/).

Hi ha un segon problema, més pràctic: l'script rep la contrasenya com a
argument, `./scorepass.sh "P@ssw0rd"`. Això la deixa escrita a l'historial de
la teva shell —a `~/.zsh_history` o `~/.bash_history`— i, mentre s'executa,
visible per a qualsevol altre usuari de la màquina que llisti els processos. Per
provar una contrasenya de debò, el [comprovador](/ca/comprovador/) d'aquest lloc
mira patrons, diccionaris i substitucions com `@` per `a`, i ho fa al teu
navegador sense enviar res.

## Quant és prou

El tutorial ven els 256 bits d'`openssl rand -base64 32` com «la mateixa força
que protegeix les transaccions bancàries». La xifra és correcta i la comparació
sobra: 256 bits és moltíssim més del que necessita una contrasenya. Amb el model
d'atac de la resta del lloc —10¹² intents per segon, sense connexió i amb un
hash ràpid—, 128 bits ja se'n van a 10¹⁹ anys. No passa res per fer-ne servir
256, però no s'ha de confondre «més» amb «necessari». Ho expliquem amb detall a
[quant triga a trencar-se una
contrasenya](/ca/blog/quant-triga-a-trencar-se-la-teva-contrasenya/).

Dos detalls dels formats, que no són de seguretat sinó d'ús:

- **base64 no és segur per a URL**, encara que el tutorial ho digui: inclou
  `+`, `/` i l'`=` del final. Aquest `=` és farciment, no atzar; els 256 bits
  viatgen als 43 caràcters del davant. Existeix una variant, base64url, que
  canvia `+` i `/` per `-` i `_`, però `openssl rand -base64` no la fa servir.
- **L'hexadecimal dona 4 bits per caràcter**, la meitat que un alfabet de
  lletres, xifres i símbols. `openssl rand -hex 32` produeix 64 caràcters i 256
  bits: perfecte per a una clau d'API. Però `genpass 16 hex` dona 16 caràcters
  i [64 bits](/ca/blog/que-son-els-bits-d-entropia/), que amb aquest mateix
  model d'atac es trenquen de mitjana en uns 107 dies. Sembla llarga; no ho és tant.

## Les paraules, i un exemple que no va sortir de cap ordre

El mode `words` treu paraules de `/usr/share/dict/words` amb `shuf`. En un Mac,
`shuf` no existeix: és de GNU i macOS no el porta, així que aquest mode
directament no funciona. La llista sí que hi és, i té 235.976 paraules, cosa que
donaria uns 71 bits amb quatre. Molt. El problema és que bona part són paraules
que no has vist mai, i la gràcia d'una frase de paraules és poder-la recordar.

L'exemple de sortida que mostra el tutorial, `correct-horse-battery-staple`, no
el va generar cap ordre: és la frase del còmic 936 d'XKCD, del 2011. Aquest
còmic té raó en el que diu —quatre paraules triades a l'atzar guanyen una
paraula amb substitucions—, però el tutorial ho resumeix com «la longitud
sempre guanya la complexitat», i això no és el que diu. El que guanya és **el
nombre d'opcions entre les quals s'ha triat a l'atzar**. Trenta-cinc «a» tenen
longitud de sobres i cap entropia. Si vols frases de paraules ben fetes,
[Diceware](/ca/blog/diceware-daus-millor-contrasenya/) fa servir una llista de
7.776 paraules pensades per recordar-se, a 12,9 bits cadascuna.

## Una versió que falla en veu alta

Això és el que proposem. La vam provar abans de publicar-la en bash i en zsh a
macOS, i en bash a 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: ha fallat" >&2; return 1; }
  printf '%s\n' "$pw"
}
```

Tres decisions, cadascuna per una de les fallades d'abans:

- **`LC_ALL=C`** davant de `tr`, perquè en un Mac llegeixi bytes i no s'aturi.
- **El guionet al final de l'alfabet**, perquè sigui un guionet. Ho vam
  verificar comptant: surten exactament els 75 caràcters que hi ha escrits, ni
  un més.
- **La comprovació de longitud.** Si per alguna raó surt una contrasenya més
  curta del que s'ha demanat, la funció no la imprimeix, avisa per la sortida
  d'errors i retorna un codi diferent de 0. Que un generador falli està bé. Que
  falli i lliuri alguna cosa és el que no pot passar.

`genpass` dona 20 caràcters d'aquest alfabet, uns 124 bits. `genpass 32` en dona
32. `genpass 6 0-9` dona un PIN. L'alfabet deixa fora a posta el `$`, l'accent
greu i les cometes: són els caràcters que una shell o un fitxer de configuració
interpreten, i una contrasenya que es trenca en enganxar-la en un `.env` no és
més segura, és més incòmoda.

## El que el tutorial encerta al final

L'última secció del tutorial és la millor: generar és fàcil, el difícil és no
repetir. Una contrasenya de 256 bits feta servir en dos llocs queda compromesa a
tots dos el dia que un dels dos pateix una filtració. La seva proposta —generar al terminal i desar en un
gestor com Bitwarden o KeePass— és exactament [l'única regla que ha
sobreviscut](/ca/blog/el-teu-gestor-contra-la-teva-memoria/).

Un últim avís sobre l'altre suggeriment, copiar al porta-retalls amb `pbcopy` o
`xclip`. És millor que imprimir-la a la pantalla, però el porta-retalls no és
un lloc privat: els gestors de porta-retalls desen historial, i en un Mac amb
Handoff activat el que copies pot aparèixer també al teu iPhone. Copia, enganxa
i copia una altra cosa a sobre.

---

*Fonts: el tutorial «Generate Unbreakable Passwords in Your Terminal Using Pure
Bash», publicat a Medium el 12 de maig de 2026 · totes les ordres es van
executar el 10 de novembre de 2026 a macOS 27.2 (bash 3.2, zsh, el `tr` del
sistema, OpenSSL 4.1) i en un contenidor Debian estable amb GNU coreutils 9.7 ·
documentació d'OpenSSL, `RAND(7)`: generador determinista segons NIST SP 800-90A
Rev. 1, sembrat des del sistema operatiu · pàgina de manual `random(4)` de
Linux · Apple, Apple Platform Security, generació de nombres aleatoris · XKCD
936, «Password Strength» (2011) · NIST SP 800-63B (2017) sobre les regles de
composició · el model d'atac, 10¹² intents per segon sense connexió i amb hash
ràpid, és el mateix que a la resta del lloc.*
