¿Cómo crear contraseñas seguras en Linux?

Me pregunto cómo puedo crear contraseñas seguras en Linux (tanto para usuarios normales como para administradores) y si hay programas específicos para hacerlo.

pwgen es uno de los muchos programas para generar contraseñas

Personalmente, prefiero no usar el generador de contraseñas ya que las contraseñas generadas son muy difíciles de recordar, pero una solución portátil es usar / dev / urandom

Crear contraseñas aleatorias que no contengan caracteres especiales tiene 10 caracteres de longitud:

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

Esto funciona al capturar bytes de / dev / urandom, eliminar los que no se ajustan al patrón especificado en el trcomando y limitarlo a 10 caracteres con head.

Crear contraseñas aleatorias que contengan caracteres especiales tiene 10 caracteres de longitud:

$ cat /dev/urandom | tr -dc 'a-zA-Z0-9-_!@#$%^&*()_+{}|:<>?=' | fold -w 10 | grep -i '[!@#$%^&*()_+{}|:<>?=]' | head -n 1
MSF4wj@vP0

Esto utiliza una técnica ligeramente diferente después de treliminar los bytes no deseados, ya que la idea es obligarlo a tener al menos un carácter especial. Esto funciona usando el foldcomando para ajustar la línea en grupos de 10, luego usando greppara buscar solo líneas que contienen un carácter especial. headluego obtiene la primera contraseña que cumple con los requisitos.

Escribí este pequeño script hace unos años y lo he estado usando desde entonces. En todo caso, se trata de un abuso interesante de printfy utiliza un precioso característica de BASH que por desgracia rara vez se ve en los guiones: typeset.

#!/usr/bin/env bash
# Released into public domain
# Aaron Bockover, 2005
# http://abock.org

typeset -i length; length=$1
typeset -i rounds; rounds=$2
[ $rounds -lt 1 ] && rounds=1
[ $length -lt 1 ] && {
    echo "Usage: $0 <length> [<rounds>]" 2>/dev/null; exit 1;
}
for ((i=0; i < $rounds; i++)); do
    for ((j=0; j < $length; j++)); do
        set=$(($RANDOM % 20))
        if   [ $set -le 6 ];  then o=65; l=26; # 35% uppercase
        elif [ $set -le 13 ]; then o=97; l=26; # 35% lowercase
        elif [ $set -le 17 ]; then o=48; l=10; # 20% numeric
        elif [ $set -le 18 ]; then o=58; l=7;  # 10% symbolic
        elif [ $set -le 19 ]; then o=33; l=15; fi
        ord=$(($o + $RANDOM % $l))
        printf \\$(($ord / 64 * 100 + $ord % 64 / 8 * 10 + $ord % 8))
    done
    echo
done

También agregaría KeePassX, que le da la opción de usar la entropía del sistema para generar contraseñas seguras con algunas características agradables, todas con GUI. También le da la opción de administrar sus contraseñas y guardarlas en un archivo cifrado.

Así es como se ve la interfaz del generador de contraseñas KPX:

apg No es una mala elección si desea una contraseña que se pueda recordar fácilmente.

; apg -m 16 -a 0 -t
ByajNudgolIston9 (Byaj-Nud-gol-Ist-on-NINE)
Af}ockhuecUjrak8 (Af-RIGHT_BRACE-ock-huec-Uj-rak-EIGHT)
IakijKadmomIvgig (Iak-ij-Kad-mom-Iv-gig)
NutIlOsyahodBeef (Nut-Il-Os-ya-hod-Beef)
anMechOybekazell (an-Mech-Oyb-ek-az-ell)
VumushCummAd{fra (Vum-ush-Cumm-Ad-LEFT_BRACE-fra)

Tenga en cuenta que de acuerdo con esto , su contraseña debe tener al menos 12 caracteres de longitud.

Utilizo un método no aleatorio, pero es lo suficientemente variado para todos los propósitos de ataque ... contraseña maestra y último pase para generar otras contraseñas. Así es como genero la contraseña maestra.

echo -n "some seed" |  openssl dgst -binary -sha1 | base64 | sed -e 's/.\{4\}/& /g'

y la salida

H1sI Wpbj JE2P CdVJ A1qb 9B/e u7M= 

ahora solo elija algunas de las secciones y cree una contraseña, reorganícelas, omita algunas, agregue un carácter o 2 para que sea tan aleatorio. Mientras pueda recordar su semilla, puede volver a generarla y recuperar su contraseña (siempre que no realice demasiadas modificaciones)

pwgen es una pequeña y maravillosa herramienta de cli que le permite especificar una serie de parámetros para establecer la complejidad, la clase de caracteres, el número de contraseñas para generar, la longitud, etc.

Aquí hay un script único para generar frases de contraseña de estilo XKCD . /usr/share/dict/wordsno es un gran diccionario para esto, ya que la mayoría de las palabras son largas, pero está fácilmente disponible. Para frases de contraseña más agradables, puede usar un diccionario de palabras cortas, como la lista de palabras de contraseña única S / Key .

dict="/usr/share/dict/words"
max="`wc -l <"$dict"`" \
    perl -e '$count=4;
        $/=\4; while (<>) {
            print unpack('L') % $ENV{max} + 1, qq(\n); last unless --$count
        }' /dev/urandom | 
    while read n ; do 
        tail -n "+$n" "$dict" | head -1
    done

Si es un usuario de GNOME y también necesita almacenar contraseñas para sus diversas cuentas, puede probar el administrador de contraseñas Revelation . Tiene una función básica de generador de contraseñas, ya que solo establece la longitud de la contraseña y elige si desea incluir caracteres de puntuación además de letras y dígitos.

Corrígeme si me equivoco, pero: Por lo que he entendido, no hay forma de que una computadora pueda crear una cadena completamente aleatoria. Entonces se me ocurrió la siguiente idea [y espero que no sea completamente estúpida]:

Si uno lanza un dado de 26 lados, la posibilidad de lanzar, digamos 26, es 1:26. En otras palabras: la probabilidad de lanzar 26 es de aproximadamente 0.04%. Además, un dado no tiene memoria ni errores. Se me ocurrió la siguiente idea:

• obtener un dado de 26 lados, donde cada lado coincide con una letra del alfabeto
• obtener un dado de diez lados donde cada lado coincida con un número entre 0 y 9
• lanza una moneda
• cabeza significa: tirar dados de cartas
• colas significa: tirar dados número

Modelos de papel para imprimir:

• Dados de 10 lados: http://www.korthalsaltes.com/model.php?name_en=decahedron
• Dados de 26 lados: http://www.korthalsaltes.com/model.php?name_en=rhombicuboctahedron

Nota : No soy un Math Pro y se me ocurrió esta idea después de leer un artículo en la revista 2600 que describe esto. Acabo de agregar algunas de mis propias ideas sobre el concepto básico.

Además : Me pregunto si este no es solo un ejemplo perfecto para ' escribir su primer craqueador de contraseñas de fuerza bruta '. Pero su pregunta me dio una razón perfecta para presentar esta idea para ser discutida.

Tengo dos alias agregados a mi archivo .zshrc.local para crear contraseñas seguras.

El primero es:

alias pw.graph="cat /dev/urandom | tr -dc '[:graph:]' | fold -w 1000 | perl -pe 's/(.)(?=.*?\1)//g' | head -n 5"

El resultado de escribir pw.graph es cinco líneas de cada carácter que se pueden escribir en un teclado con la excepción de la barra espaciadora:

/d=|&mRq!g$QaNZ'L;CfEli,D3\)*h-jkerzv?{y"_Ic(0BtxJwF59:@G}KV1X2o>S~[#]s+W%A.<6bpTO^uP7U4HMYn`8
RIdW87{a4O3][?&rTn=m/:Y`_u*hqy2c%s@!ZPM$5to1f-.U9ClK,)'jDi0"pw>EzN^|gX~BSAJk\VFG(H<bx}+Q6#vL;e
s^H@yEo/X$|d?_jw7-n'l>m"Cb\W5.tTe0APB1D!#69[p+(8x}F&~RM`q3Q%vhfOiUZz]ucJk:)*agGV;=NY4{,K2SLrI<
$/t|!s}og5u:X~hcJUyYHf>;l<zDedL`.T*K8]CBSW[(xw+Mm^E3r16b-97%'@jVR{ZG#0p4AP=,I?\n&"a)vqNkQ2iO_F
,7n|^Y\%MpeBqvhI3mE<9zPS/~+sU`4ZoCWl&uxd'ft"kjcOy0X!{a-T_6RKiVg5Hb21D)w>@*N8;A[(rLG=$Q:.#]FJ?}

El segundo es:

alias pw.alnum="cat /dev/urandom | tr -dc '[:alnum:]' | fold -w 1000 | perl -pe 's/(.)(?=.*?\1)//g' | head -n 5"

La salida de escribir pw.alnum es cada letra y número imprimible en mayúsculas y minúsculas:

E6wgCfVBbXjyzYQ8USKl79LqPih0e5mvGrNHd3osaW2OxkJ1RM4nFTtcuZIpDA
GTvQON1dsZSpJmegBMK6bqnEciU7k0AoV2H4Wh53zr9YRfLlDxywXItu8CjPFa
6u1Db9MfyBApZdU7gqoV2PGwH5LcxWi3JNj8nkQCIThezSlYEXsOtrmF04KvaR
VFrsGwI9yAmabEnlRTKgZO23vUq4f6LHkzQP7tMjNW8ph1exuDoBCXSd50JciY
G3r6Em5tlfjQARJx9gWHes7bCVwkzcP48KaSIXyUFBMLqT0op1uDNdih2nYZOv

Normalmente uso pw.graph y copio una parte aleatoria de la línea. Algunas contraseñas no permiten símbolos, así que utilizo una parte de pw.alnum para eso.

Yo uso esto guardado como un archivo .html:

<script>
var keylist="abcdefghijklmnopqrstuvwxyzABCEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*_"
var temp=''

function generatepass(plength){
temp=''
for (i=0;i<plength;i++)
temp+=keylist.charAt(Math.floor(Math.random()*keylist.length))
return temp
}

function populateform(enterlength){
document.pgenerate.output.value=generatepass(enterlength)
}
</script>

<form name="pgenerate">
<input type="text" size=32 name="output">
<input type="button" value="Generate Password" onClick="populateform(this.form.thelength.value)"><br />
<b>Password Length:</b> <input type="text" name="thelength" size=3 value="32">
</form>