Réponses:
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 tr
commande 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 tr
supprimé 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 fold
commande pour encapsuler la ligne en groupes de 10, puis en utilisant grep
pour récupérer uniquement les lignes contenant un caractère spécial. head
ré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 printf
et 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)
Voici un script unique pour générer des phrases de passe de style XKCD . /usr/share/dict/words
n'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:
Modèles de papier à imprimer:
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>
[:print:]
fortr
(tr -dc '[:print:]'
), si vous êtes un peu paranoïaque. Le problème sera alors les symboles disponibles sur votre clavier ...