# Xerar contrasinais no terminal: o que funciona e o que falla sen avisar

> O terminal é un bo xerador de contrasinais e non cómpre instalar nada. Pero probamos nun Mac os comandos dun titorial moi completo e a metade fallaban: un devolvía unha soa letra sen dar erro. Que pasa, por que, e unha versión que falla en voz alta.

2026-11-10 · David Carrero · password.es
Original: https://password.es/gl/blog/xerar-contrasinais-no-terminal/

---

En maio publicouse en Medium un titorial cun título difícil de ignorar:
*Generate Unbreakable Passwords in Your Terminal Using Pure Bash*. A idea de
fondo é boa e compartímola: **o terminal xa trae un xerador de contrasinais
excelente**, non hai que instalar nada e o contrasinal non sae da túa máquina.
É o mesmo que defende este sitio co [xerador do
navegador](/gl/blog/por-que-non-enviamos-o-teu-contrasinal/), só que sen
navegador.

Así que copiamos os seus comandos e executámolos nun Mac, o 10 de novembro de
2026, con macOS 27.2 e a configuración rexional en castelán. E nun Linux, para
comparar. O que funciona, funciona moi ben. O que falla, en varios casos, falla
sen dicir nada, que é o peor que lle pode pasar a un xerador de contrasinais.

## De onde sae o azar

O titorial abre co que de verdade importa: `openssl rand -base64 32` dáche 32
bytes aleatorios codificados en base64, e `/dev/urandom` é a fonte da que beben
case todos os demais comandos.

Un matiz, porque o titorial cóntao un pouco máis romántico do que é. Nin
`openssl rand` nin `/dev/urandom` che entregan «aleatoriedade física pura»: os
dous son un xerador criptográfico —un CSPRNG— que o sistema operativo sementa
con ruído real do hardware e que a partir de aí produce bytes que ninguén pode
predicir. OpenSSL dío na súa documentación: é un xerador determinista do modelo
NIST SP 800-90A que se sementa e se resementa só desde o sistema. Linux usa un
baseado en ChaCha20; macOS, segundo a guía de seguridade de Apple, un derivado
de Fortuna.

Non é unha pega, é a razón pola que funciona: un CSPRNG ben sementado é
exactamente o que queres. É a mesma clase de fonte que
`crypto.getRandomValues()`, a que usa o [xerador deste sitio](/gl/).

E hai outro acerto do que o titorial non presume e debería: o truco de
`tr -dc` —quedar só cos bytes que caen dentro do alfabeto e tirar o resto— **non
introduce nesgo**. É o correcto. A forma inxenua, coller o byte e facer o resto
de dividilo entre o tamaño do alfabeto, favorece uns caracteres sobre outros;
descartar non.

## Nun Mac, o comando devolve unha letra

Este é o comando do titorial para un contrasinal de letras e números:

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

No Mac, coa configuración rexional en castelán, o que sae é isto:

`tr: Illegal byte sequence`

E debaixo, un `E`. Unha soa letra. **O código de saída é 0**: para o terminal,
a operación foi ben.

A causa é que o `tr` de macOS le a entrada como texto na codificación da túa
configuración rexional, UTF-8, e os bytes aleatorios case nunca forman UTF-8
válido. En canto atopa o primeiro que non encaixa, detense. O que levaba
filtrado ata ese momento —ás veces nada, ás veces un par de caracteres— é o que
chega a `head`, e `head` non ten forma de saber que esperaba 32.

En Linux non pasa: o `tr` de GNU traballa por bytes e non mira a configuración
rexional. Probámolo nun contedor Debian e saíron os 32 caracteres. Por iso un
titorial escrito e probado en Linux pode estar perfectamente ben para quen o
escribiu e romperse no Mac de quen o le.

A solución é unha variable diante: `LC_ALL=C tr -dc …`, que lle di a `tr` que
trate a entrada como bytes. Pero o importante non é a solución, é a forma do
fallo. A función `genpass` que propón o titorial, metida no `.bashrc` dun Mac,
imprime ese `E` coma se fose un contrasinal. Se o pegas sen fixarte nun campo que
non esixe lonxitude mínima, ese pasa a ser o teu contrasinal.

## O guión que non era un guión

Para a versión «con símbolos», o titorial usa este alfabeto:

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

A intención está clara: letras, cifras e dezaoito símbolos. Pero para `tr`, un
guión entre dous caracteres é un intervalo, igual que en `a-z`. Así que `+-=`
non significa «máis, guión, igual»: significa **todo o que hai entre `+` e `=`
na táboa ASCII**, que inclúe a coma, o punto, a barra, as dez cifras, os dous
puntos, o punto e coma e o signo menor que.

Medímolo xerando dous millóns de bytes e quedando cos caracteres distintos que
saíron: 86, non os 80 que se pretendían. Igual en macOS ca en Linux. Non é un
problema de seguridade —seis caracteres máis dan algo máis de entropía, non
menos—, o problema é non saber que estás xerando. Se o sistema onde vai o
contrasinal rexeita o `;` ou o `<`, o comando falla de cando en vez e non hai
maneira de adiviñar por que. A regra é pór o guión ao final do conxunto, onde
`tr` o le como guión.

E contámolo con humildade, porque ao escribir a versión corrixida de máis abaixo
caemos nunha trampa da mesma familia: metemos o alfabeto como valor por defecto
dun parámetro, `${2:-…{}-}`, e a primeira chave de peche do alfabeto pechaba o
parámetro. O resultado xeraba unha `|` que ninguén pedira e perdera o guión.
Só o vimos porque contamos os caracteres que saían.

## 64 caracteres que ás veces son 58

O modo por defecto da función fai isto:

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

48 bytes en base64 son 64 caracteres. Pero base64 inclúe `+` e `/`, e o filtro
tíraos, así que o que queda é algo menos de 64. Para os 32 da lonxitude por
defecto sobra. Para `genpass 64`, non: executámolo 200 veces e **só 28 saíron
con 64 caracteres**; o resto, entre 58 e 63. Sen aviso.

O modo hexadecimal ten a súa propia versión do mesmo problema: divide a
lonxitude entre dous para calcular os bytes, así que `genpass 15 hex` devolve
14.

## O avaliador que aplaude a P@ssw0rd

O titorial pecha cun script que puntúa contrasinais: puntos pola lonxitude, un
por ter minúsculas, outro por maiúsculas, outro por cifras e dous por símbolos.
Executámolo con uns cantos:

- `P@ssw0rd` — **STRONG**
- `Veran2026!` — **STRONG**
- `correct-horse-battery-staple` — **STRONG**
- 35 veces a letra `a` — MODERATE

`P@ssw0rd` sae coa mesma nota que catro palabras ao chou. É das primeiras que
proba calquera dicionario de ataque. O script non o pode saber porque non mira o
que o contrasinal *é*, só de que tipos de caracteres está feito. É exactamente a
regra de «unha maiúscula, un número e un símbolo» que o NIST deixou de
recomendar en 2017, e da que xa falamos en [o xogo dos
contrasinais](/gl/blog/o-xogo-dos-contrasinais/).

Hai un segundo problema, máis práctico: o script recibe o contrasinal como
argumento, `./scorepass.sh "P@ssw0rd"`. Iso déixao escrito no historial da túa
shell —en `~/.zsh_history` ou `~/.bash_history`— e, mentres se executa, visible
para calquera outro usuario da máquina que liste os procesos. Para probar un
contrasinal de verdade, o [comprobador](/gl/comprobador/) deste sitio mira
patróns, dicionarios e substitucións como `@` por `a`, e faino no teu navegador
sen enviar nada.

## Canto é abondo

O titorial vende os 256 bits de `openssl rand -base64 32` como «a mesma forza
que protexe as transaccións bancarias». A cifra é correcta e a comparación
sobra: 256 bits é moitísimo máis do que necesita un contrasinal. Co modelo de
ataque do resto do sitio —10¹² intentos por segundo, sen conexión e cun hash
rápido—, 128 bits xa se van a 10¹⁹ anos. Non pasa nada por usar 256, pero non
hai que confundir «máis» con «necesario». Explicámolo polo miúdo en [canto tarda
en romperse un
contrasinal](/gl/blog/canto-tarda-en-romperse-o-teu-contrasinal/).

Dous detalles dos formatos, que non son de seguridade senón de uso:

- **base64 non é seguro para URL**, aínda que o titorial o diga: inclúe `+`,
  `/` e o `=` do final. Ese `=` é recheo, non azar; os 256 bits viaxan nos 43
  caracteres de diante. Existe unha variante, base64url, que cambia `+` e `/`
  por `-` e `_`, pero `openssl rand -base64` non a usa.
- **O hexadecimal dá 4 bits por carácter**, a metade que un alfabeto de letras,
  cifras e símbolos. `openssl rand -hex 32` produce 64 caracteres e 256 bits:
  perfecto para unha clave de API. Pero `genpass 16 hex` dá 16 caracteres e
  [64 bits](/gl/blog/que-son-os-bits-de-entropia/), que con ese mesmo modelo de
  ataque se rompen de media nuns 107 días. Parece longo; non o é tanto.

## As palabras, e un exemplo que non saíu de ningún comando

O modo `words` saca palabras de `/usr/share/dict/words` con `shuf`. Nun Mac,
`shuf` non existe: é de GNU e macOS non o trae, así que ese modo directamente
non funciona. A lista si está, e ten 235.976 palabras, o que daría uns 71 bits
con catro. Moito. O problema é que boa parte son palabras que non viches nunca,
e a graza dunha frase de palabras é poder lembrala.

O exemplo de saída que amosa o titorial, `correct-horse-battery-staple`, non o
xerou ningún comando: é a frase da viñeta 936 de XKCD, de 2011. Esa viñeta ten
razón no que di —catro palabras escollidas ao chou gañan a unha palabra con
substitucións—, pero o titorial resúmeo como «a lonxitude gaña sempre á
complexidade», e iso non é o que di. O que gaña é **o número de opcións entre as
que se escolleu ao chou**. Trinta e cinco «a» teñen lonxitude de sobra e
ningunha entropía. Se queres frases de palabras ben feitas,
[Diceware](/gl/blog/diceware-dados-mellor-contrasinal/) usa unha lista de 7.776
palabras pensadas para lembrarse, a 12,9 bits cada unha.

## Unha versión que falla en voz alta

Isto é o que propoñemos. Probámola antes de publicala en bash e en zsh sobre
macOS, e en bash sobre 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: fallou" >&2; return 1; }
  printf '%s\n' "$pw"
}
```

Tres decisións, cada unha por un dos fallos de arriba:

- **`LC_ALL=C`** diante de `tr`, para que nun Mac lea bytes e non se deteña.
- **O guión ao final do alfabeto**, para que sexa un guión. Verificámolo
  contando: saen exactamente os 75 caracteres que hai escritos, nin un máis.
- **A comprobación de lonxitude.** Se por calquera motivo sae un contrasinal
  máis curto do pedido, a función non o imprime, avisa pola saída de erros e
  devolve un código distinto de 0. Que un xerador falle está ben. Que falle e
  entregue algo é o que non pode pasar.

`genpass` dá 20 caracteres dese alfabeto, uns 124 bits. `genpass 32` dá 32.
`genpass 6 0-9` dá un PIN. O alfabeto deixa fóra a propósito o `$`, o acento
grave e as comiñas: son os caracteres que unha shell ou un ficheiro de
configuración interpretan, e un contrasinal que se rompe ao pegalo nun `.env`
non é máis seguro, é máis incómodo.

## O que o titorial acerta ao final

A última sección do titorial é a mellor: xerar é fácil, o difícil é non
repetir. Un contrasinal de 256 bits usado en dous sitios queda comprometido en
ambos o día que un dos dous sofre unha filtración. A súa proposta —xerar no terminal e gardar nun xestor
como Bitwarden ou KeePass— é exactamente [a única regra que
sobreviviu](/gl/blog/o-teu-xestor-contra-a-tua-memoria/).

Un último aviso sobre a outra suxestión, copiar ao portapapeis con `pbcopy` ou
`xclip`. É mellor que imprimilo na pantalla, pero o portapapeis non é un sitio
privado: os xestores de portapapeis gardan historial, e nun Mac con Handoff
activado o que copias pode aparecer tamén no teu iPhone. Copia, pega e copia
outra cousa enriba.

---

*Fontes: o titorial «Generate Unbreakable Passwords in Your Terminal Using Pure
Bash», publicado en Medium o 12 de maio de 2026 · todos os comandos se
executaron o 10 de novembro de 2026 en macOS 27.2 (bash 3.2, zsh, o `tr` do
sistema, OpenSSL 4.1) e nun contedor Debian estable con GNU coreutils 9.7 ·
documentación de OpenSSL, `RAND(7)`: xerador determinista segundo NIST SP
800-90A Rev. 1, sementado desde o sistema operativo · páxina de manual
`random(4)` de Linux · Apple, Apple Platform Security, xeración de números
aleatorios · XKCD 936, «Password Strength» (2011) · NIST SP 800-63B (2017) sobre
as regras de composición · o modelo de ataque, 10¹² intentos por segundo sen
conexión e con hash rápido, é o mesmo do resto do sitio.*
