Comment générer une chaîne aléatoire?

Je souhaite générer une chaîne aléatoire (par exemple, mots de passe, noms d'utilisateur, etc.). Il devrait être possible de spécifier la longueur requise (par exemple 13 caractères).

Quels outils puis-je utiliser?

(Pour des raisons de sécurité et de confidentialité, il est préférable que les chaînes soient générées hors ligne, plutôt qu'en ligne sur un site Web.)

Ma façon préférée de le faire est d’utiliser /dev/urandomavec trpour supprimer les caractères indésirables. Par exemple, pour obtenir uniquement des chiffres et des lettres:

head /dev/urandom | tr -dc A-Za-z0-9 | head -c 13 ; echo ''

Vous pouvez également inclure plus de caractères de la liste des caractères spéciaux du mot de passe OWASP :

</dev/urandom tr -dc 'A-Za-z0-9!"#$%&'\''()*+,-./:;<=>?@[\]^_`{|}~' | head -c 13  ; echo

Si vous ne parvenez pas à vous trplaindre de l'entrée, essayez d'ajouterLC_ALL=C ceci:

LC_ALL=C tr -dc 'A-Za-z0-9!"#$%&'\''()*+,-./:;<=>?@[\]^_`{|}~' </dev/urandom | head -c 13 ; echo

Pour générer un mot de passe aléatoire, vous pouvez utiliser pwgen:

pwgen génère des mots de passe aléatoires, dépourvus de sens, mais prononçables. Ces mots de passe ne contiennent que des lettres minuscules, ou des lettres majuscules et minuscules, ou des chiffres ajoutés. Les lettres majuscules et les chiffres sont placés de manière à faciliter le rappel de leur position lorsqu’on ne mémorise que le mot.

Générez 7 mots de passe de longueur 13:

geek@liv-inspiron:~$ pwgen 13 7
Eu7Teadiphaec giepahl3Oyaiy iecoo9Aetaib4 phaiChae6Eivi athoo3igee8Co
Iphu4ufeDeelo aesoYi2lie9he 

Comme mentionné dans les commentaires, vous pouvez éviter de réduire l'entropie en utilisant l' -sargument (c.-à-d. Générer des mots de passe plus sûrs, complètement aléatoires mais difficiles à retenir):

geek@liv-inspiron:~$ pwgen -s 13 7
eAfycrPlM4cYv 4MRXmZmyIVNBp D8y71iqjG7Zq7 FQRHcserl4R8O yRCUtPtV3dsqV
0vJpp2h0OrgF1 QTp7MKtJyTrjz 

Pour générer des noms d'utilisateur aléatoires, vous pouvez utiliser gpw:

Ce paquet génère des mots de passe prononçables. Il utilise les statistiques des combinaisons de trois lettres (trigraphes) tirées des dictionnaires que vous lui fournissez.

Générez 7 mots de passe (noms d'utilisateur) de longueur 13:

geek@liv-inspiron:~$ gpw 7 13
sreepoidahsas
risadiestinge
ntodynesssine
deodstestress
natinglumperm
riasigentspir
enderiferback

J'utilise la opensslcommande, le couteau suisse de cryptographie.

openssl rand -base64 12

ou

openssl rand -hex 12

Voici comment je le fais. Il génère une chaîne aléatoire de 10 caractères. Vous pouvez l'optimiser en remplaçant le "fold" par d'autres outils de traitement de chaînes.

cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 10 | head -n 1

Pour générer un mot de passe avec la meilleure entropie possible avec les outils Linux standard intégrés à chaque distribution que j'utilise:

< /dev/urandom tr -cd "[:print:]" | head -c 32; echo

Tous les caractères imprimables ASCII sont générés - de 32 (espace) à 126 (tilde, ~). Le mot de passe peut être contrôlé avec le head« s -cdrapeau. Il existe également d'autres jeux de caractères possibles tr(pour ne pas inclure l'espace, mais uniquement les caractères 33-126, à utiliser [:graph:]).

En fonction du niveau de hasard que vous souhaitez, vous pouvez simplement utiliser la variable intégrée de bash ( zshet kshéventuellement d'autres) $RANDOM:

$ echo $RANDOM | tr '[0-9]' '[a-z]'
bfeci
$ echo $RANDOM | tr '[0-9]' '[a-z]'
cijjj

Les méthodes de lecture directe à partir de /dev/urandomsont beaucoup plus simples, mais pour compléter, vous pouvez également utiliser $RANDOM:

echo $(for((i=1;i<=13;i++)); do printf '%s' "${RANDOM:0:1}"; done) | tr '[0-9]' '[a-z]'

Important : cette solution ne produira que des chaînes aléatoires utilisant les 10 premières lettres de l'alphabet. Que cela vous suffise ou non dépend de ce dont vous avez besoin.

Inspiré par Pablo Repetto, je me suis retrouvé avec cette solution facile à retenir :

shuf -zer -n20  {A..Z} {a..z} {0..9}

-z évite les sorties multi-lignes

-e fait écho au résultat

-r permet à n'importe quel caractère d'apparaître plusieurs fois

-n20 chaîne aléatoire d'une longueur de 20 caractères

{A..Z} {a..z} {0..9} classes de caractères autorisées

shuf fait partie des coreutils linux et est largement disponible ou du moins a été porté.

@Brandin a expliqué dans un commentaire à une autre réponse comment obtenir au maximum 100 octets en /dev/urandomutilisant head -c 100. Une autre façon de faire est avec dd:

tr -dc A-Za-z0-9 < /dev/urandom | dd bs=100 count=1 2>/dev/null

À 2>/dev/nullla fin de la ddcommande, vous supprimez la sortie "... records in / ... records out".

Je ne connais pas d'avantages / inconvénients substantiels entre ces deux méthodes.

J'ai eu un problème avec les deux méthodes de se trplaindre de l'entrée. Je pensais que c'était parce qu'il n'aimait pas recevoir d'entrée binaire, et par conséquent j'ai suggéré de commencer par filtrer /dev/randomavec iconv -c -t US. Cependant, Gilles a suggéré un diagnostic et une solution différents, ce qui fonctionne pour moi:

LC_ALL=C tr -dc A-Za-z0-9 </dev/urandom | dd bs=100 count=1 2>/dev/null

APG est inclus par défaut sur certaines distributions Linux.

Pour générer des mots de passe de tailles 5 à 10 dans les sous-ensembles Spécial, Numérique, Capital et Inférieur, la commande est la suivante:

apg -MSNCL -m 5 -x 10

Et revient

@OpVeyhym9
3:Glul
3DroomIc?
hed&Os0
NefIj%Ob3
35Quok}

Comme l'a dit @landroni dans un commentaire.

Vous pouvez utiliser l'un des md5outils ayant précisément cet objectif. Dans le cas de la création d'un mot de passe complètement aléatoire, vous pouvez utiliser le fichier md5pass. C’est un outil très simple à utiliser et très utile, car vous pouvez utiliser du "texte normal" avec un "sel" pour construire rapidement le même mot de passe que vous pourrez récupérer par la suite, ou vous voudrez peut-être obtenir une mot de passe aléatoire tout le temps. L'utilisation générale est:

md5pass [password] [salt]

où passwordest un mot choisi qui sera utilisé pour la construction de la chaîne aléatoire et saltest le saut en octets à utiliser. Comme ça:

md5pass word

$1$.MUittVW$j.XDTF1QRnxqFdXRUiSLs0

Cela créera un mot de passe "une séquence aléatoire" que vous utiliserez. Si vous utilisez no salt, vous ne pourrez peut-être pas recréer cette même chaîne par la suite.

Cependant si vous utilisez un saltcomme ceci:

md5pass word 512

$1$512$.0jcLPQ83jgszaPT8xzds0

alors vous pouvez créer une séquence que vous pourrez récupérer si vous utilisez le mot conjointement avec le même sel (ou saut) s'il avait été défini à l'origine.

Utilisez la xxdcommande pour spécifier la longueur (via -l) qui fonctionne à la fois sous Linux et OS. https://www.howtoforge.com/linux-xxd-command/

xxd -l16 -ps /dev/urandom

Ces deux commandes génèrent des mots de passe aléatoires et des phrases secrètes, respectivement.

shuf --random-source=/dev/urandom --repeat --head-count=20 file_with_characters | tr --delete '\n'

shuf --random-source=/dev/urandom --repeat --head-count=7 file_with_words | tr '\n' ' '

Le générateur de mot de passe requiert un nombre file_with_characters contenant tous les caractères que le mot de passe doit utiliser, un caractère par ligne et une fois chacun. Le fichier ne doit pas contenir de lignes vierges et les lignes doivent être terminées par une nouvelle ligne.

Le générateur de phrase secrète nécessite un fichier file_with_words contenant tous les mots que la phrase secrète doit utiliser, un mot par ligne et une fois chacun. Le fichier ne doit pas contenir de lignes vierges et les lignes doivent être terminées par une nouvelle ligne.

L'option --head-count spécifie la longueur du mot de passe - en caractères - ou du mot de passe - en mots.

J'ai trouvé que piping / dev / urandom pour tracer sur macOS ne fonctionnait pas. Voici un autre moyen:

set="abcdefghijklmonpqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
n=6
rand=""
for i in `seq 1 $n`; do
    char=${set:$RANDOM % ${#set}:1}
    rand+=$char
done
echo $rand

J'utilise:

base64 < /dev/urandom | tr -d 'O0Il1+\' | head -c 44

Cela me donne 57 caractères possibles. La chaîne peut être copiée -collée (supprimée +et \) ou imprimée et retapée car les caractères difficiles à distinguer ( I1lO0) ont été supprimés.

• 44 caractères me donne: log ₂ (57 ⁴⁴ )> 256,64 bits d'entropie
• 22 caractères me donne: log ₂ (57 ²² )> 128,32 bits d'entropie

J'aime ça parce que:

• la commande est simple à saisir et mémorable
• il utilise des outils système standard - pas de fichiers binaires supplémentaires
• ne "gaspille" pas beaucoup au hasard (utilise 89% des bits aléatoires qu'il reçoit, par rapport à ~ 24% pour les solutions allant directement de la tuyauterie à tr)
• 22 et 44 caractères se marient assez bien (juste au-dessus de la paire) puissance commune de deux points d'arrêt
• la sortie peut être facilement sélectionnée et collée ou imprimée et retapée avec un taux d'erreur humain minimal
• Des solutions plus courtes que les hexa (32 et 64 au lieu de 22 et 44) telles que md5sum / sha1sum, etc.

Nous remercions https://unix.stackexchange.com/a/230676/9583 et plus particulièrement les commentaires de mon inspiration initiale.

La philosophie Unix de "beaucoup de petits outils qui font bien une chose" vous est très utile dans ce cas.

• /dev/urandomest un flux de "octets" aléatoires (qui incluent des caractères non imprimables)
• base64 encode les données d'octet dans [A-Za-z0-9/+] (qui est entièrement imprimable)
• dd copie les entrées vers les sorties en appliquant les modificateurs donnés en arguments (pouvant inclure la taille et le nombre de blocs)

OSX

base64     < /dev/urandom | dd bs=1k count=1

Linux

base64 -w0 < /dev/urandom | dd bs=1k count=1

Remarques:

• Si vous avez besoin d'un sous-ensemble de caractères, vous pouvez insérer un modificateur dans le canal.
  • Ex: tr -d '[A-Z/+]'se débarrasser des majuscules et +et/
• Vous pouvez définir la bs(taille de bloc) à la longueur dont vous avez besoin.
• Sous Linux, le nombre base64de colonnes est de 76 par défaut et doit être réinitialisé à -w0moins que vous ne le vouliez.

Je souhaite contribuer à ma commande habituelle pour générer un mot de passe

$ cat /dev/urandom | base64 | head -n 1 |tr -dc '[:alnum:]' |cut -c -13
b0R55751vWW9V

Pour configurer la longueur du mot de passe, définissez le nombre dans la commande de découpe sur la longueur souhaitée, par exemple 24 caractères.

$ cat /dev/urandom | base64 | head -n 1 |tr -dc '[:alnum:]' |cut -c -24
WFBhVHuKbrnRhd5kdWXPzmZG

Vous ne voulez pas confondre 0 ou O, 1 ou l? Filtrez-le avec un autretr

$ cat /dev/urandom | base64 | head -n 1 |tr -dc '[:alnum:]' | tr -d '0O1l'|cut -c -24
JuCphwvhrhppD9wVqfpP2beG

Personnellement, je ne préfère jamais le caractère spécial dans le mot de passe, c'est pourquoi je ne choisis que [:alnum:]pour mon générateur de mot de passe

Je maintiens secpwgendans Alpine Linux et garde les sources sur mon Github .

Il peut produire des chaînes de caractères aléatoires ou des phrases Diceware:

musl64 [~]$ secpwgen
USAGE: secpwgen <-p[e] | -A[adhsy] | -r | -s[e]> N

PASSPHRASE of N words from Diceware dictionary
  -p    generate passphrase
  -pe   generate enhanced (with symbols) passphrase

SKEY PASSWORD of N words from S/Key dictionary
  -s    generate passphrase
  -se   generate enhanced (with symbols) passphrase

ASCII RANDOM of N elements (at least one option MUST be present)
  -A    Each letter adds the following random elements in output:
    a    alphanumeric characters
    d    decimal digits
    h    hexadecimal digits
    s    special characters
    y    3-4 letter syllables

RAW RANDOM
  -r    output BASE64 encoded string of N random BITS
  -k    output koremutake encoding of N random BITS

Pour générer une chaîne aléatoire de 13 caractères, vous utiliseriez:

musl64 [~]$ secpwgen -Aas 13
----------------
WK5#*V<]M3<CU ;ENTROPY=67.21 bits
----------------
INFO: destroying random number generator.
INFO: zeroing memory.

musl64 [~]$ secpwgen -Aa 13
----------------
GP0FIEBM9Y3BT ;ENTROPY=67.21 bits
----------------
INFO: destroying random number generator.
INFO: zeroing memory.

Pour que les utilisateurs se souviennent d'un mot de passe, utilisez les expressions suivantes:

musl64 [~]$ secpwgen -p 5
----------------
wq seen list n8 kerr  ;ENTROPY=65.00 bits
----------------
INFO: destroying random number generator.
INFO: zeroing memory.

J'aime personnellement:

musl64 [~]$ secpwgen -r 512
----------------
h62lL7G4gwh3/j9c7YteQvVXoqJrQKKPWVR3Lt7az36DcfWZWtUgBT19iwmJBwP4UahNzPe7qYD7OcklUFpCzQ== ;ENTROPY=512.00 bits
----------------
INFO: destroying random number generator.
INFO: zeroing memory.

Mon chemin pour un mot de passe très sécurisé (où 16 est la longueur de pw):

cat /dev/urandom | tr -cd [:graph:]|head -c 16

Exemple de résultat:

jT@s_Nx]gH<wL~W}

Ou alternativement, pour générer plusieurs mots de passe:

cat / dev / urandom | tr -cd [: graph:] | fold -w 16 | head -6

Exemple de résultat:

7ck%G7'|f&}_8(]s
<?*]E.CG[NB'gK#A
:tF-WPTOa3!i7S(h
2xy(>=%3=Kb1B$`6
*98Lf{d?Jzb}6q1\
E7uCEAN2Hz]]y|5*

Peu moins sécurisé (jeu de caractères plus petit):

cat /dev/urandom |base64 -w 0|fold -w 16|head -6

Exemple de résultat:

rJqYxYZLOTV+A45w
PUKQ+BoBf6yfZw5m
+LRfpsN9CsLRiN8V
yMS6zDpL6NHmG17s
yTUWPG7Rum97schi
cognvjVwaKaAyPRK

Un moyen très facile et simple (probablement plus simple que ce que vous cherchez) pour y parvenir serait de générer un nombre aléatoire dans une plage donnée, de convertir ce nombre en son caractère ASCII équivalent et de l'ajouter à la fin d'une chaîne. .

Voici un exemple de base en Python:

import random # import random library  
passFile = open("passwords.txt", 'w') # create file passwords.txt
passNum = int(input("Number of passwords: ")) # get number of  passwords
passLength = int(input("Password length: ")) # get length of passwords  
for i in range(passNum):
    password = "" # reset password
    for i in range(passLength):
        num = random.randint(65, 122) # get random number
        while num in range(91, 97): # Don't include punctuation
            num = random.randint(65, 122)
        password += chr(num) # add character to current password 
    passFile.write(password + "\n") # add current password to file  
passFile.close() # close file

EDIT: ajout de commentaires et de code pour générer plusieurs mots de passe et les écrire dans un fichier

Je voudrais cette commande:

date +%s | sha256sum | base64 | head -c 12

Je vais, sur http://passwordsgenerator.net/, il permet de générer des chaînes de caractères aléatoires allant jusqu'à 2 048 caractères, en sélectionnant des majuscules, des minuscules, des chiffres de 0 à 9, des signes de ponctuation ou toute autre combinaison.