it-swarm-es.tech

¿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.

25
Gasuma

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

23
theotherreceive

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

La creación de contraseñas aleatorias que no contienen caracteres especiales tiene 10 caracteres:

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

Esto funciona tomando bytes de/dev/urandom, eliminando los que no se ajustan al patrón especificado en el comando tr y limitándolo a 10 caracteres con head.

La creación de contraseñas aleatorias que contienen caracteres especiales tiene 10 caracteres:

$ cat /dev/urandom | tr -dc '[email protected]#$%^&*()_+{}|:<>?=' | fold -w 10 | grep -i '[[email protected]#$%^&*()_+{}|:<>?=]' | head -n 1
[email protected]

Esto usa una técnica ligeramente diferente después de que tr elimina los bytes no deseados, ya que la idea es forzarlo a tener al menos un carácter especial. Esto funciona usando el comando fold para envolver la línea en grupos de 10, luego usando grep para buscar solo líneas que contienen un carácter especial. head luego obtiene la primera contraseña que cumple con los requisitos.

17
Hemant

Escribí este pequeño guión hace unos años y lo he estado usando desde entonces. En todo caso, es un abuso interesante de printf y usa una característica encantadora de BASH que desafortunadamente rara vez veo en los scripts: 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
11
Aaron Bockover

También agregaría KeePassX , que le brinda la opción de usar la entropía del sistema para generar contraseñas seguras con algunas características agradables, todas usando GUI. También le brinda 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:

enter image description here

4
pootzko

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.

Utilizo una contraseña no aleatoria, pero es lo suficientemente variada para todos los propósitos de ataque ... contraseña maestra, y última pasada 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 bueno como al azar. Siempre que pueda recordar su semilla, puede regenerarla y recuperar su contraseña (siempre que no realice demasiadas modificaciones)

2
xenoterracide

Aquí hay un script único para generar estilo XKCD contraseñas. /usr/share/dict/words no es un gran diccionario para esto ya que la mayoría de las palabras son largas, pero está fácilmente disponible. Para obtener frases de contraseña más agradables, puede usar un diccionario de palabras cortas como Lista de palabras de contraseña de un solo uso de 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
1
Jander

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

1
slashdot

Corrígeme si me equivoco, pero: Hasta donde yo lo entendí, no hay ninguna forma en que una computadora pueda generar una cadena completamente aleatoria. Así que se me ocurrió la siguiente idea [y espero que no sea del todo estúpida]:

Si uno lanza un dado de 26 caras, 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:

  • consigue un dado de 26 caras, donde cada lado coincide con una letra del alfabeto
  • consigue un dado de diez caras donde cada lado coincide con un número entre 0 y 9
  • lanza una moneda
  • cabeza significa: lanzar dados de letras
  • colas significa: lanzar dados numéricos

Modelos de papel para imprimir:

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

También : Me pregunto si esto no es solo un ejemplo perfecto para ' ¡escribe tu primer cracker de contraseñas de fuerza bruta' . Pero su pregunta me dio una razón perfecta para presentar esta idea para discutirla.

0
erch

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 son 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%[email protected]!ZPM$5to1f-.U9ClK,)'jDi0"pw>EzN^|gX~BSAJk\VFG(H<bx}+Q6#vL;e
s^[email protected]/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?}

La segunda es:

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

El resultado de escribir pw.alnum son todas las letras y números imprimibles tanto en mayúscula como en minúscula:

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.

0
J363

Yo uso esto guardado como un archivo .html:

<script>
var keylist="[email protected]#$%^&*_"
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>
0
Michael Prokopec

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

0
Francesco Turco