Comment créer des mots de passe forts sous Linux?

Je me demande comment je peux créer des mots de passe forts sous Linux (pour les utilisateurs normaux et administrateurs) et s'il existe des programmes spécifiques pour le faire.

pwgen est l'un des nombreux programmes de génération de mots de passe

Personnellement, je préfère ne pas utiliser le générateur de mot de passe car les mots de passe générés sont très difficiles à retenir, mais une solution portable consiste à utiliser / dev / urandom

La création de mots de passe aléatoires qui ne contient aucun caractère spécial est de 10 caractères:

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

Cela fonctionne en récupérant les octets de / dev / urandom, en supprimant ceux qui ne correspondent pas au modèle spécifié dans la trcommande et en le limitant à 10 caractères avec head.

La création de mots de passe aléatoires contenant des caractères spéciaux comprend 10 caractères:

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

Cela utilise une technique légèrement différente après avoir trsupprimé les octets indésirables, car l'idée est de le forcer à avoir au moins un caractère spécial. Cela fonctionne en utilisant la foldcommande pour encapsuler la ligne en groupes de 10, puis en utilisant greppour récupérer uniquement les lignes contenant un caractère spécial. headrécupère ensuite le premier mot de passe qui répond aux exigences.

J'ai écrit ce petit script il y a quelques années et je l'utilise depuis. Si quoi que ce soit, il est un abus intéressant printfet utilise une belle caractéristique de BASH que je vois malheureusement que rarement dans les 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

J'ajouterais également KeePassX qui vous donne la possibilité d'utiliser l'entropie du système pour générer des mots de passe forts avec quelques fonctionnalités intéressantes - toutes utilisant une interface graphique. Il vous donne également la possibilité de gérer vos mots de passe et de les enregistrer dans un fichier crypté.

Voici à quoi ressemble l'interface du générateur de mots de passe KPX:

apg n'est pas un mauvais choix si vous voulez un mot de passe facile à retenir.

; 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)

Notez qu'en fonction de cela , votre mot de passe doit comporter au moins 12 caractères.

J'utilise un non aléatoire, mais est assez varié pour toutes les fins d'attaque ... mot de passe maître, et dernier passage pour générer d'autres mots de passe. Voici comment je génère le mot de passe principal.

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

et la sortie

H1sI Wpbj JE2P CdVJ A1qb 9B/e u7M= 

il suffit maintenant de choisir quelques-unes des sections et de créer un mot de passe, de les réorganiser, de les laisser de côté, d'ajouter un caractère ou 2 pour le rendre aussi aléatoire que possible. Tant que vous vous souvenez de votre graine, vous pouvez le régénérer et récupérer votre mot de passe (tant que vous n'effectuez pas trop de modifications)

pwgen est un merveilleux petit outil cli qui vous permet de spécifier un certain nombre de paramètres pour définir la complexité, le nombre de classes de caractères de mots de passe à générer, la longueur, etc.

Voici un script unique pour générer des phrases de passe de style XKCD . /usr/share/dict/wordsn'est pas un excellent dictionnaire pour cela car la plupart des mots sont longs, mais il est facilement disponible. Pour des mots de passe plus agréables, vous pouvez utiliser un dictionnaire de mots courts tels que la liste de mots de passe S / Key One-Time Password .

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 vous êtes un utilisateur GNOME et que vous devez également stocker des mots de passe pour vos différents comptes, vous pouvez essayer le gestionnaire de mots de passe Revelation . Il dispose d'une fonction de génération de mot de passe de base, en ce sens que vous définissez uniquement la longueur du mot de passe et choisissez si vous souhaitez inclure des caractères de ponctuation en plus des lettres et des chiffres.

Corrigez-moi si je me trompe, mais: Pour autant que je l'ai compris, il n'y a aucun moyen qu'un ordinateur puisse proposer une chaîne complètement aléatoire. J'ai donc eu l'idée suivante [et j'espère que ce n'est pas complètement stupide]:

Si l'on lance un dé à 26 faces, la chance de lancer, disons 26 est 1:26. En d'autres termes: la chance de lancer 26 est d'environ 0,04%. De plus, un dé n'a ni mémoire ni bogue. J'ai eu l'idée suivante:

• obtenir un dé 26 faces, où chaque côté correspond à une lettre de l'alphabet
• obtenir un dé à dix faces où chaque côté correspond à un nombre compris entre 0 et 9
• lancer une pièce
• tête signifie: lancer des dés de lettre
• queues signifie: lancer des dés

Modèles de papier à imprimer:

• Dés à 10 faces: http://www.korthalsaltes.com/model.php?name_en=decahedron
• Dés 26 faces: http://www.korthalsaltes.com/model.php?name_en=rhombicuboctahedron

Remarque : je ne suis pas un Math Pro et j'ai eu cette idée après avoir lu un article dans le magazine 2600 qui décrivait cela. Je viens d'ajouter quelques-unes de mes propres idées sur le concept de base.

Aussi : je me demande si ce n'est pas seulement un exemple parfait pour « écrire votre premier cracker de mot de passe par force brute ». Mais votre question m'a donné une raison parfaite de proposer cette idée pour discussion.

J'ai deux alias ajoutés à mon fichier .zshrc.local pour créer des mots de passe forts.

Le premier est:

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

Le résultat de la saisie de pw.graph est de cinq lignes de chaque caractère qui peuvent être saisies sur un clavier à l'exception de la barre d'espace:

/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?}

Le second est:

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

La sortie de la saisie de pw.alnum correspond à chaque lettre et chiffre imprimable à la fois en majuscule et en minuscule:

E6wgCfVBbXjyzYQ8USKl79LqPih0e5mvGrNHd3osaW2OxkJ1RM4nFTtcuZIpDA
GTvQON1dsZSpJmegBMK6bqnEciU7k0AoV2H4Wh53zr9YRfLlDxywXItu8CjPFa
6u1Db9MfyBApZdU7gqoV2PGwH5LcxWi3JNj8nkQCIThezSlYEXsOtrmF04KvaR
VFrsGwI9yAmabEnlRTKgZO23vUq4f6LHkzQP7tMjNW8ph1exuDoBCXSd50JciY
G3r6Em5tlfjQARJx9gWHes7bCVwkzcP48KaSIXyUFBMLqT0op1uDNdih2nYZOv

J'utilise généralement pw.graph et copie une partie aléatoire de la ligne. Certains mots de passe n'autorisent pas les symboles, j'utilise donc une partie de pw.alnum pour cela.

J'utilise ceci enregistré en tant que fichier .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>