Depende de lo que quieres decir con "legible". Si desea usar solo caracteres hexadecimales, necesitará 32 de ellos para alcanzar 128 bits de entropía; esta línea funcionará (usando solo comandos del paquete coreutils ):

head -c16 /dev/urandom | md5sum

Esta variante genera contraseñas con solo letras minúsculas, desde 'a' hasta 'p' (esto es lo que querrá si tiene que "escribir" la contraseña en un teléfono inteligente):

head -c16 /dev/urandom | md5sum | tr 0-9 g-p

Si desea escribir uno menos caracteres, intente esto:

head -16 /dev/urandom | md5sum

(La probabilidad de obtener todos los primeros 16 bytes aleatorios como 0x0A, es decir, el carácter de "nueva línea", es 2 ^-128 , por lo que esta línea aún tiene 128 bits de entropía).

Aún limitándote a los comandos de coreutils , puedes hacer esto:

mktemp -u XXXXXXXXXXXXXXXXXXXXXX

Este genera una contraseña de 22 caracteres, utilizando /dev/urandom como fuente interna de aleatoriedad (verifiqué el código fuente y confirma una llamada strace ). Los caracteres son letras (mayúsculas y minúsculas) y dígitos; ya que 62 ²² es mayor que 2 ¹²⁸ , los 22 caracteres son suficientes.

Otra más:

od -An -x /dev/urandom | head -1

esto muestra ocho secuencias de cuatro dígitos hexadecimales. Podría decirse que esta división en pequeñas secuencias puede ayudar a la lectura.

Para una línea mucho más larga y un tipo de contraseña bastante distinto, intente esto:

for i in {1..8} ; do head -$(expr $(head -c7 /dev/urandom | od -An -t dL) % $(wc -l < /usr/share/dict/british-english)) /usr/share/dict/british-english | tail -1 ; done

(este funciona solo en un host de 64 bits; ¿notará por qué?). Aparte de coreutils , esa versión también requiere un archivo de diccionario, aquí el del inglés británico.

Algunas sugerencias fabulosas en las otras respuestas. Me parece que makepasswd no está disponible en todas partes, y usar tr es (un poco) complicado, por lo que hay otra opción utilizando OpenSSL:

openssl rand -base64 16

El número es el número de bytes de aleatoriedad, por lo que 16 bytes para 128 bits de entropía.

Usando pwgen

Oneliner más simple que nunca:

pwgen

Intenta crear contraseñas que sean fáciles de recordar. Para deshabilitar eso y crear contraseñas más seguras, use el indicador --secure o -s .

pwgen -s

¿Las contraseñas generadas son demasiado largas? ¿Demasiado corto? Simplemente agregue la longitud deseada:

pwgen 9
# Or
pwgen -s 9
# Or
pwgen 9 -s

Herramientas similares

Por casualidad sé que pwgen, hay otras herramientas por ahí. Puedes encontrarlos usando la función de búsqueda de tu distribución. En Debian esto es:

apt-cache search password generator

Hace una búsqueda exacta (aunque no distingue entre mayúsculas y minúsculas). El uso de password generat en lugar de ampliar la búsqueda.

Antes de instalar el paquete puede ser útil ver su descripción. De nuevo en Debian:

apt-cache show $DESIRED_PACKAGE
# E.g.
apt-cache show pwgen

Herramientas que podría encontrar de esta manera:

• pwgen
• makepasswd
• apg
• otp (destinado a almohadillas de una sola vez, no recomendado)
• gpw (se enfoca principalmente en la pronunciabilidad, no recomendado)

Usando herramientas estándar de Unix

No todos los sistemas pueden tener pwgen disponible. Como han respondido otros, puedes usar md5sum o sha256sum , pero eso solo genera las salidas 0-9 y a-f. No g-z o mayúsculas y minúsculas, y mucho menos caracteres especiales. Es mejor simplemente filtrar los caracteres no imprimibles de /dev/urandom hasta que tenga una contraseña de la longitud deseada:

cat /dev/urandom | tr -cd '@-~' | head -c 8

Lo que da algo como XiVsdn[y o V@FPV^lY . Puede cambiar el 8 al final para la longitud de contraseña deseada. También puede cambiar la parte @-~ para limitar los caracteres. Por ejemplo, esto solo imprimirá caracteres alfanuméricos:

cat /dev/urandom | tr -cd 'a-zA-Z0-9' | head -c 8

Esto es casi idéntico a lo que haría pwgen -s y da contraseñas como nZiUzNtE .

Como beneficio adicional, la herramienta tr se incluye en casi todos los sistemas operativos (Mac OS X, GNU / Linux, Android / Linux, Solaris, FreeBSD, etc.) excepto Microsoft Windows.

Dependiendo del tipo de caracteres que puede incluir, un comando fácil para crear una contraseña legible con 128 bits de entropía tiene este aspecto:

< /dev/urandom tr -dc [:graph:] | head -c20; echo;

(Tomado de aquí ). [:graph:] son todos caracteres priables ascii excepto el espacio.

Explicación:

128 bits son equivalentes a 3.40e + 38 combinaciones. Si está utilizando los 94 caracteres ASCII legibles (excepto el espacio) , necesitará 20 caracteres para alcanzar al menos esa cantidad de combinaciones: 94 ^ 20 = 2.90e + 39 .

Si, por ejemplo, solo puedes usar _A-Za-z0-9 :

< /dev/urandom tr -dc '_A-Za-z0-9' | head -c22; echo;

Para 63 caracteres posibles: 63 ^ 22 = 3.85e + 39 . Solo agrega dos caracteres para alcanzar la entropía completa.

Para contraseñas hexadecimales:

< /dev/urandom tr -dc 'A-F0-9' | head -c32; echo;

El hexadecimal es fácil: 128 bits son 32 veces más que los bits de un carácter hexadecimal.

Aviso importante : en la mayoría de las situaciones en las que necesitas una contraseña, usarás una función hash detrás, que derivará la cadena real que se usará. Este análisis está sujeto a la forma en que se utiliza / recorta la contraseña.

Nota adicional : /dev/urandom es seguro para esta operación. Compruebe Es un rand de / dev / urandom seguro para una clave de inicio de sesión? .

Nota adicional : si está usando más de una iteración con una función hash, puede restar los bits necesarios para expresar la iteración de las cantidades totales de bits que puede alcanzar, por ejemplo:

65536 iteraciones = 2 ^ 16 iteraciones, agregue aproximadamente 16 bits (2 bytes) de entropía a la contraseña elegida, porque en una ataque de fuerza bruta, debes realizar 2 ^ 16 iteraciones adicionales antes de calcular el hash utilizado.

Solo para el registro, ir más allá de 128 bits de entropía, es innecesario como se explica aquí: ¿Cantidad de operaciones simples que están fuera del alcance de toda la humanidad?

Pero si tu paranoia va más allá de eso, aquí hay algunos números útiles:

Todos los ascii legibles ( 29 caracteres , 1.6e + 57 combinaciones), 192 bits (6.28e + 57 combinaciones) de entropía:

< /dev/urandom tr -dc [:graph:] | head -c29; echo;

_A-Za-z0-9 ( 32 caracteres , 3.79e + 57 combinaciones), 192 bits (6.28e + 57 combinaciones) de entropía:

< /dev/urandom tr -dc '_A-Za-z0-9' | head -c32; echo;

A-F0-9 ( 48 caracteres , 16 ^ 48 combinaciones), 192 bits (2 ^ 192 combinaciones) de entropía:

< /dev/urandom tr -dc 'A-F0-9' | head -c48; echo;

Todos los ascii legibles ( 39 caracteres , 8.95e + 76 combinaciones), 256 bits (1.16e + 77 combinaciones) de entropía:

< /dev/urandom tr -dc [:graph:] | head -c39; echo;

_A-Za-z0-9 ( 43 caracteres , 2.35e + 77 combinaciones), 256 bits (1.16e + 77 combinaciones) de entropía:

< /dev/urandom tr -dc '_A-Za-z0-9' | head -c43; echo;

A-F0-9 ( 64 caracteres , 16 ^ 64 combinaciones), 256 bits (2 ^ 256 combinaciones) de entropía:

< /dev/urandom tr -dc 'A-F0-9' | head -c64; echo;

Teniendo en cuenta que las últimas seis opciones ya son paranoicas, es completamente inútil elegir contraseñas más complejas o más grandes que las descritas anteriormente.

Una sola línea para crear una contraseña legible y relativamente fácil de recordar:

cat /usr/share/dict/words | shuf -n 4 | tr '\n' ' '| tr -d \'

Salida de ejemplo:

correct horse battery staple

Si desea una contraseña más larga, cambie el 4 a un número más alto. Para una contraseña sin espacios, agregue un espacio de escape al final de la línea:

cat /usr/share/dict/words | shuf -n 4 | tr '\n' ' ' | tr -d \ \'

Hay un paquete llamado makepasswd que puede hacer esto.

 $ makepasswd --chars 64

Yo usaría apg con semilla de 16 bytes desde / dev / urandom (máximo permitido)

apg -a 0 -d -m 15 -n 1 -c "'head -c16 /dev/urandom'"; echo

Puedes encadenar los comandos apg para tener una contraseña más larga con más entropía.

Para que la información aleatoria sea legible, podemos codificarla en base64. Un personaje en base64 tiene 6 bits de entropía. Por lo tanto, para 128 bits de entropía necesita 22 caracteres (128/6 = 21 + ⅓).

Esto nos lleva al comando:

base64 < /dev/urandom | head -c 22

Se puede traducir al inglés mediante "generar datos aleatorios de calidad criptográfica con / dev / urandom y convertirlos a base64, mantener los primeros 22 caracteres".

Es posible que desee agregar un carácter de "fin de línea" adicional al final de la salida:

echo $(base64 < /dev/urandom | head -c 22)

Sé que pediste una línea, pero en realidad es más robusta con más. ;-)

El trabajo principal se puede comprimir en una sola línea si desea eliminar la verificación de errores y la compatibilidad en diferentes versiones de la utilidad base64 ; Esta implementación funciona tanto en OS X como en Linux. (vea la función create_password y reemplace do_base64 con solo base64 con los argumentos apropiados). Puede reemplazar la función do_base64 con su propia función para seleccionar caracteres ASCII en base a una entrada binaria, pero utilizando base64 (con sed para eliminar / , + y = ), esto le pone en mayúsculas, minúsculas y números. ( 26 + 26 + 10 = 62 ; no estoy seguro de a qué 94 caracteres se refería).

Especifique la longitud de la contraseña que desea como argumento.

#!/bin/bash

function abort {
    echo "Error: $*"
    exit 2
}

function do_base64 {
    WRAP=""
    base64 --help | grep -q -- --wrap && WRAP="-w 0"
    base64 $WRAP $@
}

function create_password {
    let bytes=$1*2
    dd if=/dev/urandom 2> /dev/null bs=$bytes count=1 \
        | do_base64 \
        | sed s/[\/\+=]//g \
        | cut -c 1-${1}
}

if [ "$1" == "" ]; then
    echo "Usage: $0 <desired-password-length>"
    exit 1
fi
let length=0+"$1" 2> /dev/null || abort "Password length must be numeric"

create_password $1

Salida de ejemplo:

$ mkpasswd 16
2LjxTkQHP7Lv4z0J

$ mkpasswd 24
txhhbeHfGZSl0UNRvsz78yFo

$ mkpasswd 64
TykZF3hMXcZp0rP4ig0d9zRsuVEDxHjIcLHGcNaf0ROhk66VCPc7tE8GXcVv7AKh

Además, probablemente querrá reemplazar /dev/urandom con /dev/random si le interesa obtener la entropía adecuada. (Lo cambié a /dev/urandom durante el desarrollo desde que se agotó mi grupo de entropía).

uuidgen

le proporcionará un UUID; recuerde verificar qué versión de UUID genera en su computadora, ya que algunas versiones permitirán que alguien que fisgonee su contraseña la rastree en su computadora, lo que puede (probablemente es) un problema de seguridad. Puedes usar

uuidgen -r

para asegurarse de que la ID solo conste de dígitos aleatorios (ish) y no pueda ser rastreada. La cadena constará de [a-z0-9] y -. Ejemplo de salida:

  

4bc1b05b-77b5-4a4c-8300-e9dc53350fcb

La calidad de la cadena depende de la capacidad de su sistema operativo para generar números aleatorios ( /dev/random ).

Aquí hay una función que construye una contraseña con un mínimo de 128 bits de entropía usando números aleatorios entre 33 y 126.

pgen() {
    local start=33 end=126 # printable, non-whitespace characters
    local entropy=128

    # Calculate minimum length to meet required entropy
    local length=$(echo "($entropy/(l($((end+1-start)))/l(2)))" | bc -l)
    length=$(echo "scale=0; ($length+0.5)/1" | bc) # round result up

    # Use $1 as length if it has enough entropy
    [ -n "$1" ] && [ $1 -gt $length 2>/dev/null ] && length=$1

    for _ in $(seq $length); do
        printf \$(printf '%03o' \
            $(shuf --random-source=/dev/urandom -i $start-$end -n1))
    done
    echo
}

La función calcula la longitud mínima requerida para cumplir con los requisitos de entropía (longitud de 20 en este caso) y genera una contraseña de esa longitud.

El primer argumento puede especificar la longitud de la contraseña escrita en la salida estándar, siempre que sea mayor que la longitud mínima para cumplir el requisito de entropía.

$ pgen
xx6r6e%Og;_8<4)o#aPO