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, 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— STRONGVerano2026!— STRONGcorrect-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.
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 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.
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_, peroopenssl rand -base64no la usa. - El hexadecimal da 4 bits por carácter, la mitad que un alfabeto de letras,
cifras y símbolos.
openssl rand -hex 32produce 64 caracteres y 256 bits: perfecto para una clave de API. Perogenpass 16 hexda 16 caracteres y 64 bits, 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 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:
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=Cdelante detr, 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.
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.
Foto de Luis Gomes · Pexels