Un liner pour créer des mots de passe sous Linux?
Comment créer un mot de passe lisible en utilisant bash avec une ligne? Et si je recherche 128 bits d'entropie?
[~ # ~] modifier [~ # ~]
Par lisible, j'entends les 94 caractères ascii imprimables (sans espace). Il peut utiliser moins de ces caractères tant qu'il a au moins 128 bits d'entropie.
Cela dépend de ce que vous entendez par "lisible". Si vous souhaitez utiliser uniquement des caractères hexadécimaux, vous en aurez besoin de 32 pour atteindre 128 bits d'entropie; cette ligne fonctionnera (en utilisant uniquement les commandes du package coreutils):
head -c16 /dev/urandom | md5sum
Cette variante produit des mots de passe avec uniquement des lettres minuscules, de 'a' à 'p' (c'est ce que vous voudrez si vous devez "taper" le mot de passe sur un smartphone):
head -c16 /dev/urandom | md5sum | tr 0-9 g-p
Si vous souhaitez saisir un caractère de moins, essayez ceci:
head -16 /dev/urandom | md5sum
(La probabilité d'obtenir les 16 premiers octets aléatoires sous la forme 0x0A, c'est-à-dire le caractère "nouvelle ligne", est de 2-128, d'où cette ligne obtient toujours 128 bits d'entropie.)
En vous limitant toujours aux commandes de coreutils, vous pouvez faire ceci:
mktemp -u XXXXXXXXXXXXXXXXXXXXXX
Celui-ci génère un mot de passe de 22 caractères, en utilisant /dev/urandom comme source interne de caractère aléatoire (j'ai vérifié le code source et un appel à strace confirme). Les caractères sont des lettres (majuscules et minuscules) et des chiffres; depuis 6222 est supérieur à 2128, les 22 caractères suffisent.
Encore un autre:
od -An -x /dev/urandom | head -1
cela affiche huit séquences de quatre chiffres hexadécimaux. On peut dire que cette division en petites séquences peut aider à la lecture.
Pour une ligne beaucoup plus longue et un type de mot de passe bien distinct, essayez ceci:
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
(celui-ci ne fonctionne que sur un hôte 64 bits; remarquerez-vous pourquoi?). Outre coreutils, cette version nécessite également un fichier dictionnaire, ici celui de l'anglais britannique.
Quelques suggestions fabuleuses dans les autres réponses. Je trouve que makepasswd n'est pas disponible partout, et l'utilisation de tr est (légèrement) délicate, il y a donc une autre option en utilisant OpenSSL:
openssl Rand -base64 16
Le nombre est le nombre d'octets aléatoires - donc 16 octets pour 128 bits d'entropie.
Utilisation de pwgen
Oneliner le plus simple de tous les temps:
pwgen
Il tente de créer des mots de passe faciles à retenir. Pour désactiver cela et créer des mots de passe plus sécurisés, utilisez le --secure ou -s drapeau.
pwgen -s
Les mots de passe générés sont-ils trop longs? Trop court? Ajoutez simplement la longueur souhaitée:
pwgen 9
# Or
pwgen -s 9
# Or
pwgen 9 -s
Outils similaires
Il se trouve que je connais pwgen, il existe d'autres outils. Vous pouvez les trouver en utilisant la fonction de recherche de votre distribution. Dans Debian, c'est:
apt-cache search password generator
Il effectue une recherche exacte (mais insensible à la casse). En utilisant password generat élargit plutôt la recherche.
Avant d'installer le package, il peut être utile de consulter sa description. Encore dans Debian:
apt-cache show $DESIRED_PACKAGE
# E.g.
apt-cache show pwgen
Des outils que j'ai pu trouver de cette façon:
pwgenmakepasswdapgotp(destiné aux pads à usage unique, non recommandé)gpw(se concentre fortement sur la prononçabilité, non recommandé)
Utilisation des outils Unix standard
Tous les systèmes peuvent ne pas avoir pwgen disponible. Comme d'autres l'ont répondu, vous pouvez utiliser md5sum ou sha256sum, mais qui ne produit que 0-9 et a-f. Pas de g-z ou de casse mixte, sans parler de caractères spéciaux. Il vaut mieux filtrer simplement les caractères non imprimables de /dev/urandom jusqu'à ce que vous ayez un mot de passe de la longueur souhaitée:
cat /dev/urandom | tr -cd '@-~' | head -c 8
Ce qui donne quelque chose comme XiVsdn[y ou V@FPV^lY. Vous pouvez modifier le 8 à la fin pour la longueur de mot de passe souhaitée. Vous pouvez également modifier le @-~ partie pour limiter les caractères. Par exemple, cela n'imprimera que des caractères alphanumériques:
cat /dev/urandom | tr -cd 'a-zA-Z0-9' | head -c 8
C'est presque identique à ce que pwgen -s ferait l'affaire et donne des mots de passe comme nZiUzNtE.
En prime, l'outil tr est inclus dans presque tous les systèmes d'exploitation (Mac OS X, GNU/Linux, Android/Linux, Solaris, FreeBSD, etc.) à l'exception de Microsoft Windows.
Selon le type de caractères que vous pouvez inclure, une commande simple pour créer un mot de passe lisible avec 128 bits d'entropie ressemble à ceci:
< /dev/urandom tr -dc [:graph:] | head -c20; echo;
(Tiré de ici ). [:graph:] sont tous des caractères valables ascii sauf l'espace.
Explication:
128 bits équivalent à 3,40e + 38 combinaisons. Si vous utilisez les 94 caractères ascii lisibles (sauf l'espace), vous aurez besoin 20 caractères pour atteindre au moins ce nombre de combinaisons: 94 ^ 20 = 2,90e + 39 .
Si, par exemple, vous n'êtes autorisé qu'à utiliser _A-Za-z0-9:
< /dev/urandom tr -dc '_A-Za-z0-9' | head -c22; echo;
Pour 63 caractères possibles: 63 ^ 22 = 3.85e + 39 . Il n'ajoute que deux caractères pour atteindre l'entropie complète.
Pour les mots de passe hexadécimaux:
< /dev/urandom tr -dc 'A-F0-9' | head -c32; echo;
Hexadécimal est facile: 128 bits sont 32 fois les bits d'un caractère hexadécimal.
Avis important : La plupart des situations où vous avez besoin d'un mot de passe, vous utiliserez une fonction de hachage derrière, qui dérivera en fait la vraie chaîne qui sera être utilisé. Cette analyse est soumise à la façon dont le mot de passe est haché/utilisé.
Remarque supplémentaire : /dev/urandom est sécurisé pour cette opération. Veuillez vérifier n Rand de/dev/urandom est-il sécurisé pour une clé de connexion? .
Remarque supplémentaire : Si vous utilisez plusieurs itérations avec une fonction de hachage, vous pouvez soustraire les bits nécessaires pour exprimer l'itération des quantités totales de bits que vous pouvez atteindre, par exemple:
65536 itérations = 2 ^ 16 itérations, ajoutez environ 16 bits (2 octets) d'entropie au mot de passe choisi, car dans une attaque par force brute, vous devez effectuer 2 ^ 16 itérations supplémentaires avant de calculer le hachage utilisé.
Juste pour mémoire, aller au-delà de 128 bits d'entropie, est inutile comme expliqué ici: Nombre d'opérations simples hors de portée de toute l'humanité?
Mais si votre paranoïa va au-delà, voici quelques chiffres utiles:
Tous les ascii lisibles ( 29 caractères , 1.6e + 57 combinaisons), 192 bits (6.28e + 57 combinaisons) d'entropie:
< /dev/urandom tr -dc [:graph:] | head -c29; echo;
_A-Za-z0-9 ( 32 caractères , 3,79e + 57 combinaisons), 192 bits (6.28e + 57 combinaisons) d'entropie:
< /dev/urandom tr -dc '_A-Za-z0-9' | head -c32; echo;
A-F0-9 ( 48 caractères , 16 ^ 48 combinaisons), 192 bits (2 ^ 192 combinaisons) d'entropie:
< /dev/urandom tr -dc 'A-F0-9' | head -c48; echo;
Tous les ascii lisibles ( 39 caractères , 8,95e + 76 combinaisons), 256 bits (1.16e + 77 combinaisons) d'entropie:
< /dev/urandom tr -dc [:graph:] | head -c39; echo;
_A-Za-z0-9 ( 43 caractères , 2,35e + 77 combinaisons), 256 bits (1.16e + 77 combinaisons) d'entropie:
< /dev/urandom tr -dc '_A-Za-z0-9' | head -c43; echo;
A-F0-9 ( 64 caractères , 16 ^ 64 combinaisons), 256 bits (2 ^ 256 combinaisons) d'entropie:
< /dev/urandom tr -dc 'A-F0-9' | head -c64; echo;
Étant donné que les six dernières options sont déjà paranoïaques, il est complètement inutile de choisir des mots de passe plus complexes ou plus grands que ceux décrits ci-dessus.
Un one-liner pour créer un mot de passe lisible et relativement facile à retenir:
cat /usr/share/dict/words | shuf -n 4 | tr '\n' ' '| tr -d \'
Exemple de sortie:
correct horse battery staple
Si vous souhaitez un mot de passe plus long, remplacez le 4 par un chiffre plus élevé. Pour un mot de passe sans espaces, ajoutez un espace d'échappement à la fin de la ligne:
cat /usr/share/dict/words | shuf -n 4 | tr '\n' ' ' | tr -d \ \'
Il existe un package appelé makepasswd qui peut le faire.
$ makepasswd --chars 64
J'utiliserais apg avec une graine de 16 octets de/dev/urandom (maximum autorisé)
apg -a 0 -d -m 15 -n 1 -c "`head -c16 /dev/urandom`"; echo
Vous pouvez enchaîner les commandes apg afin d'avoir un mot de passe plus long avec plus d'entropie.
Pour que les informations aléatoires soient lisibles, nous pouvons les encoder en base64. Un caractère en base64 a 6 bits d'entropie. Ainsi, pour 128 bits d'entropie, vous avez besoin de 22 caractères (128/6 = 21 + ⅓).
Cela nous amène à la commande:
base64 < /dev/urandom | head -c 22
Ce qui peut être traduit en anglais par "générer des données aléatoires de qualité cryptographique avec/dev/urandom et les convertir en base64, garder les 22 premiers caractères".
Vous voudrez peut-être ajouter un caractère "fin de ligne" supplémentaire à la fin de la sortie:
echo $(base64 < /dev/urandom | head -c 22)
uuidgen
vous fournira un UUID; n'oubliez pas de vérifier quelle version d'UUID il génère sur votre ordinateur car certaines versions permettront à quelqu'un qui espionne votre mot de passe de le suivre sur votre ordinateur, ce qui peut (probablement) être un problème de sécurité. Vous pouvez utiliser
uuidgen -r
pour vous assurer que l'ID se compose uniquement de chiffres aléatoires (ish) et ne peut pas être suivi jusqu'à vous. La chaîne comprendra [a-z0-9] et -. Exemple de sortie:
4bc1b05b-77b5-4a4c-8300-e9dc53350fcb
La qualité de la chaîne dépend de la capacité de votre système d'exploitation à générer des nombres aléatoires (/dev/random).
Je sais que vous avez demandé une ligne, mais c'est vraiment plus robuste avec plus. ;-)
Le travail principal peut être compressé sur une seule ligne si vous souhaitez éliminer la vérification des erreurs et la compatibilité entre les différentes versions de base64 utilitaire; cette implémentation fonctionne à la fois sur OS X et Linux. (voir le create_password, et remplacez do_base64 avec simplement base64 avec les arguments appropriés.) Vous pouvez remplacer le do_base64 fonction avec votre propre fonction pour sélectionner ASCII caractères basés sur une entrée binaire, mais en utilisant base64 (avec un sed pour éliminer le /, +, et =) cela vous donne des majuscules, des minuscules et des nombres. (26 + 26 + 10 = 62; Je ne sais pas quels 94 caractères vous vouliez dire.)
Spécifiez la longueur de mot de passe souhaitée comme argument.
#!/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
Exemple de sortie:
$ mkpasswd 16
2LjxTkQHP7Lv4z0J
$ mkpasswd 24
txhhbeHfGZSl0UNRvsz78yFo
$ mkpasswd 64
TykZF3hMXcZp0rP4ig0d9zRsuVEDxHjIcLHGcNaf0ROhk66VCPc7tE8GXcVv7AKh
De plus, vous voudrez probablement remplacer /dev/urandom avec /dev/random si vous voulez obtenir une entropie appropriée. (Je l'ai changé en /dev/urandom pendant le développement depuis que mon pool d'entropie a été épuisé.)
Voici une fonction qui construit un mot de passe avec un minimum de 128 bits d'entropie en utilisant des nombres aléatoires entre 33 et 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 fonction calcule la longueur minimale requise pour répondre aux exigences d'entropie (longueur de 20 dans ce cas) et génère un mot de passe de cette longueur.
Le premier argument peut spécifier la longueur du mot de passe écrit sur stdout, tant qu'il est supérieur à la longueur minimale pour répondre aux exigences d'entropie.
$ pgen
xx6r6e%Og;_8<4)o#aPO