# Generar contraseñas en la terminal: lo que funciona y lo que falla sin avisar

> La terminal es un buen generador de contraseñas y no hace falta instalar nada. Pero probamos en un Mac los comandos de un tutorial muy completo y la mitad fallaban: uno devolvía una sola letra sin dar error. Qué pasa, por qué, y una versión que falla en voz alta.

Publicado el 2026-11-10 por David Carrero · password.es
Original: https://password.es/blog/generar-contrasenas-en-la-terminal/

---

En mayo se publicó en Medium un tutorial con un título difícil de ignorar:
*Generate Unbreakable Passwords in Your Terminal Using Pure Bash*. La idea de
fondo es buena y la compartimos: **la terminal ya trae un generador de
contraseñas excelente**, no hay que instalar nada y la contraseña no sale de tu
máquina. Es lo mismo que defiende este sitio con [el generador del
navegador](/blog/por-que-no-enviamos-tu-contrasena/), solo que sin navegador.

Así que copiamos sus comandos y los ejecutamos en un Mac, el 10 de noviembre de
2026, con macOS 27.2 y la configuración regional en español. Y en un Linux, para
comparar. Lo que funciona funciona muy bien. Lo que falla, en varios casos,
falla sin decir nada, que es lo peor que le puede pasar a un generador de
contraseñas.

## De dónde sale el azar

El tutorial abre con lo que de verdad importa: `openssl rand -base64 32` te da
32 bytes aleatorios codificados en base64, y `/dev/urandom` es la fuente de la
que beben casi todos los demás comandos.

Un matiz, porque el tutorial lo cuenta un poco más romántico de lo que es. Ni
`openssl rand` ni `/dev/urandom` te entregan «aleatoriedad física pura»: los dos
son un generador criptográfico —un CSPRNG— que el sistema operativo siembra con
ruido real del hardware y que a partir de ahí produce bytes que nadie puede
predecir. OpenSSL lo dice en su documentación: es un generador determinista del
modelo NIST SP 800-90A que se siembra y se resiembra solo desde el sistema.
Linux usa uno basado en ChaCha20; macOS, según la guía de seguridad de Apple,
uno derivado de Fortuna.

No es una pega, es la razón por la que funciona: un CSPRNG bien sembrado es
exactamente lo que quieres. Es la misma clase de fuente que
`crypto.getRandomValues()`, la que usa el [generador de este sitio](/).

Y hay otro acierto que el tutorial no presume y debería: el truco de
`tr -dc` —quedarse solo con los bytes que caen dentro del alfabeto y tirar el
resto— **no introduce sesgo**. Es lo correcto. La forma ingenua, tomar el byte y
hacer el resto de dividir entre el tamaño del alfabeto, favorece unos
caracteres sobre otros; descartar no.

## En un Mac, el comando devuelve una letra

Este es el comando del tutorial para una contraseña de letras y números:

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

En el Mac, con la configuración regional en español, lo que sale es esto:

`tr: Illegal byte sequence`

Y debajo, una `E`. Una sola letra. **El código de salida es 0**: para la
terminal, la operación ha ido bien.

La causa es que el `tr` de macOS lee la entrada como texto en la codificación
de tu configuración regional, UTF-8, y los bytes aleatorios casi nunca forman
UTF-8 válido. En cuanto encuentra el primero que no encaja, se para. Lo que
llevaba filtrado hasta ese momento —a veces nada, a veces un par de
caracteres— es lo que llega a `head`, y `head` no tiene forma de saber que
esperaba 32.

En Linux no pasa: el `tr` de GNU trabaja por bytes y no mira la configuración
regional. Lo probamos en un contenedor Debian y salieron los 32 caracteres. Por
eso un tutorial escrito y probado en Linux puede estar perfectamente bien para
quien lo escribió y romperse en el Mac de quien lo lee.

El arreglo es una variable delante: `LC_ALL=C tr -dc …`, que le dice a `tr` que
trate la entrada como bytes. Pero lo importante no es el arreglo, es la forma
del fallo. La función `genpass` que propone el tutorial, metida en el
`.bashrc` de un Mac, imprime esa `E` como si fuera una contraseña. Si la pegas
sin mirar en un campo que no exige longitud mínima, ya la tienes puesta.

## El guion que no era un guion

Para la versión «con símbolos», el tutorial usa este alfabeto:

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

La intención está clara: letras, cifras y dieciocho símbolos. Pero para `tr`,
un guion entre dos caracteres es un rango, igual que en `a-z`. Así que `+-=` no
significa «más, guion, igual»: significa **todo lo que hay entre `+` y `=` en la
tabla ASCII**, que incluye la coma, el punto, la barra, las diez cifras, los
dos puntos, el punto y coma y el signo menor que.

Lo medimos generando dos millones de bytes y quedándonos con los caracteres
distintos que salieron: 86, no los 80 que se pretendían. Igual en macOS que en
Linux. No es un problema de seguridad —seis caracteres más dan algo más de
entropía, no menos—, es un problema de saber qué estás generando. Si el sistema
donde va la contraseña rechaza el `;` o el `<`, el comando falla de vez en
cuando y no hay manera de adivinar por qué. La regla es poner el guion al final
del conjunto, donde `tr` lo lee como guion.

Y lo contamos con humildad, porque al escribir la versión corregida de abajo
caímos en una trampa de la misma familia: metimos el alfabeto como valor por
defecto de un parámetro, `${2:-…{}-}`, y la primera llave de cierre del
alfabeto cerraba el parámetro. El resultado generaba una `|` que nadie había
pedido y había perdido el guion. Solo lo vimos porque contamos los caracteres
que salían.

## 64 caracteres que a veces son 58

El modo por defecto de la función hace esto:

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

48 bytes en base64 son 64 caracteres. Pero base64 incluye `+` y `/`, y el
filtro los tira, así que lo que queda es algo menos de 64. Para las 32 de la
longitud por defecto sobra. Para `genpass 64`, no: lo ejecutamos 200 veces y
**solo 28 salieron con 64 caracteres**; el resto, entre 58 y 63. Sin aviso.

El modo hexadecimal tiene su propia versión del mismo problema: divide la
longitud entre dos para calcular los bytes, así que `genpass 15 hex` devuelve
14.

## El puntuador que aplaude a P@ssw0rd

El tutorial cierra con un script que puntúa contraseñas: puntos por la
longitud, uno por tener minúsculas, otro por mayúsculas, otro por cifras y dos
por símbolos. Lo ejecutamos con unas cuantas:

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

`P@ssw0rd` sale con la misma nota que cuatro palabras al azar. Es de las
primeras que prueba cualquier diccionario de ataque. El script no lo puede saber porque no mira lo
que la contraseña *es*, solo de qué tipos de caracteres está hecha. Es
exactamente la regla de «una mayúscula, un número y un símbolo» que NIST dejó
de recomendar en 2017, y de la que ya hablamos en [el juego de las
contraseñas](/blog/el-juego-de-las-contrasenas/).

Hay un segundo problema, más práctico: el script recibe la contraseña como
argumento, `./scorepass.sh "P@ssw0rd"`. Eso la deja escrita en el historial de
tu shell —en `~/.zsh_history` o `~/.bash_history`— y, mientras se ejecuta,
visible para cualquier otro usuario de la máquina que liste los procesos. Para
probar una contraseña de verdad, el [comprobador](/comprobador/) de este sitio
mira patrones, diccionarios y sustituciones como `@` por `a`, y lo hace en tu
navegador sin enviar nada.

## Cuánto es bastante

El tutorial vende los 256 bits de `openssl rand -base64 32` como «la misma
fuerza que protege las transacciones bancarias». La cifra es correcta y la
comparación sobra: 256 bits es muchísimo más de lo que necesita una contraseña.
Con el modelo de ataque del resto del sitio —10¹² intentos por segundo, sin
conexión y con un hash rápido—, 128 bits ya se van a 10¹⁹ años. No pasa nada
por usar 256, pero no hay que confundir «más» con «necesario». Lo explicamos
con calma en [cuánto tarda en romperse una
contraseña](/blog/cuanto-tarda-en-romperse-tu-contrasena/).

Dos detalles de los formatos, que no son de seguridad sino de uso:

- **base64 no es seguro para URL**, aunque el tutorial lo diga: incluye `+`, `/`
  y el `=` del final. Ese `=` es relleno, no azar; los 256 bits viajan en los
  43 caracteres de delante. Existe una variante, base64url, que cambia `+` y
  `/` por `-` y `_`, pero `openssl rand -base64` no la usa.
- **El hexadecimal da 4 bits por carácter**, la mitad que un alfabeto de letras,
  cifras y símbolos. `openssl rand -hex 32` produce 64 caracteres y 256 bits:
  perfecto para una clave de API. Pero `genpass 16 hex` da 16 caracteres y
  [64 bits](/blog/que-son-los-bits-de-entropia/), que con ese mismo modelo de
  ataque caen de media en unos 107 días. Parece larga; no lo es tanto.

## Las palabras, y un ejemplo que no salió de ningún comando

El modo `words` saca palabras de `/usr/share/dict/words` con `shuf`. En un Mac,
`shuf` no existe: es de GNU y macOS no lo trae, así que ese modo directamente
no funciona. La lista sí está, y tiene 235.976 palabras, lo que daría unos 71
bits con cuatro. Mucho. El problema es que buena parte son palabras que no has
visto nunca, y la gracia de una frase de palabras es poder recordarla.

El ejemplo de salida que muestra el tutorial, `correct-horse-battery-staple`,
no lo generó ningún comando: es la frase del cómic 936 de XKCD, de 2011. Ese
cómic tiene razón en lo que dice —cuatro palabras elegidas al azar ganan a una
palabra con sustituciones— pero el tutorial lo resume como «la longitud gana
siempre a la complejidad», y eso no es lo que dice. Lo que gana es **el número
de opciones entre las que se eligió al azar**. Treinta y cinco aes tienen
longitud de sobra y ninguna entropía. Si quieres frases de palabras bien
hechas, [Diceware](/blog/diceware-dados-mejor-contrasena/) usa una lista de
7.776 palabras pensadas para recordarse, a 12,9 bits cada una.

## Una versión que falla en voz alta

Esto es lo que proponemos. La probamos antes de publicarla en bash y en zsh sobre macOS, y 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: ha fallado" >&2; return 1; }
  printf '%s\n' "$pw"
}
```

Tres decisiones, cada una por uno de los fallos de arriba:

- **`LC_ALL=C`** delante de `tr`, para que en un Mac lea bytes y no se pare.
- **El guion al final del alfabeto**, para que sea un guion. Lo verificamos
  contando: salen exactamente los 75 caracteres que hay escritos, ni uno más.
- **La comprobación de longitud.** Si por lo que sea sale una contraseña más
  corta de lo pedido, la función no la imprime, avisa por la salida de errores
  y devuelve un código distinto de 0. Que un generador falle está bien. Que
  falle y entregue algo es lo que no puede pasar.

`genpass` da 20 caracteres de ese alfabeto, unos 124 bits. `genpass 32` da 32.
`genpass 6 0-9` da un PIN. El alfabeto deja fuera a propósito `$`, la comilla
invertida y las comillas: son los caracteres que una shell o un fichero de
configuración interpretan, y una contraseña que se rompe al pegarla en un
`.env` no es más segura, es más incómoda.

## Lo que el tutorial acierta al final

La última sección del tutorial es la mejor: generar es fácil, lo difícil es no
repetir. Una contraseña de 256 bits usada en dos sitios cae entera el día que
se filtra uno de los dos. Su propuesta —generar en la terminal y guardar en un
gestor como Bitwarden o KeePass— es exactamente [la única regla que ha
sobrevivido](/blog/tu-gestor-contra-tu-memoria/).

Un último aviso sobre la otra sugerencia, copiar al portapapeles con `pbcopy`
o `xclip`. Es mejor que imprimirla en pantalla, pero el portapapeles no es un
sitio privado: los gestores de portapapeles guardan historial, y en un Mac con
Handoff activado lo que copias puede aparecer también en tu iPhone. Copia, pega y
copia otra cosa encima.

---

*Fuentes: el tutorial «Generate Unbreakable Passwords in Your Terminal Using
Pure Bash», publicado en Medium el 12 de mayo de 2026 · todos los comandos se
ejecutaron el 10 de noviembre de 2026 en macOS 27.2 (bash 3.2, zsh, el `tr` del
sistema, OpenSSL 4.1) y en un contenedor Debian estable con
GNU coreutils 9.7 · documentación de OpenSSL, `RAND(7)`: generador determinista
según NIST SP 800-90A Rev. 1, sembrado desde el sistema operativo · página de
manual `random(4)` de Linux · Apple, Apple Platform Security, generación de
números aleatorios · XKCD 936, «Password Strength» (2011) · NIST SP 800-63B
(2017) sobre las reglas de composición · el modelo de ataque, 10¹² intentos por
segundo sin conexión y con hash rápido, es el mismo del resto del sitio.*
