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

Question

Je souhaite générer une chaîne aléatoire (par exemple, mots de passe, noms d'utilisateurs, 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.)

herbert · Answer

Ma façon préférée de le faire est d'utiliser /dev/urandom avec tr pour 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 ''

Alternativement, pour inclure plusieurs 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 avez des problèmes avec tr se plaignant de l'entrée, essayez d'ajouter LC_ALL=C comme ceci:

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

400 the Cat · Answer

J'utilise la commande openssl, le couteau suisse de la cryptographie.

openssl Rand -base64 12

ou

openssl Rand -hex 12

landroni · Answer

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énués de sens mais prononçables. Ces mots de passe contiennent uniquement des lettres minuscules, ou des majuscules et des minuscules mélangées, ou des chiffres ajoutés. Les lettres majuscules et les chiffres sont placés de manière à faciliter la mémorisation de leur position lors de la mémorisation uniquement du 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 le -s argument (c'est-à-dire 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'utilisateurs aléatoires, vous pouvez utiliser gpw:

Ce package 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 l'alimentez.

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

x1b2j · Answer

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 "pli" par d'autres outils de traitement de chaîne.

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

entwicklerseite · Answer

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

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

-z évite la sortie multi-lignes

-e fait écho au résultat

-r permet à n'importe quel personnage d'apparaître plusieurs fois

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

{A..Z} {a..z} {0..9} classes char autorisées

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

drws · Answer

Pour générer un mot de passe avec l'entropie la plus élevée possible avec des outils Linux standard intégrés à chaque distribution que j'utilise:

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

Cela génère tous les caractères ASCII imprimables - de 32 (espace) à 126 (tilde, ~). La longueur du mot de passe peut être contrôlée avec le head's -c drapeau. Il y a aussi d'autres jeux de caractères possibles dans tr (pour ne pas inclure l'espace, juste les caractères 33-126, utilisez [:graph:]).

terdon · Answer

Selon le niveau d'aléatoire souhaité, vous pouvez simplement utiliser les fonctions bash (également zsh et ksh, éventuellement d'autres) intégrées $RANDOM variable:

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

Les méthodes lisant directement à partir de /dev/urandom sont beaucoup plus simples, mais dans un souci d’achèvement, 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.

dubiousjim · Answer

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

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

Le 2>/dev/null à la fin de la commande dd consiste à supprimer la sortie "... enregistrements entrants/... enregistrements sortants".

Je ne connais aucun avantage/inconvénient substantiel entre ces deux méthodes.

J'ai eu un problème avec les deux méthodes de tr se plaindre de l'entrée. Je pensais que c'était parce qu'il n'aimait pas recevoir d'entrée binaire, et j'ai donc suggéré le premier filtrage /dev/random avec iconv -c -t US. Cependant, Gilles a suggéré un diagnostic et une solution différents, qui fonctionnent pour moi:

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

northtree · Answer

Utilisez la commande xxd 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

Sandburg · Answer

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

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

apg -MSNCL -m 5 -x 10

Et retourne

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

Comme l'a dit @landroni en commentaire.

Joke Sr. OK · Answer

Vous pouvez utiliser l'un des md5 des outils qui ont 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 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 un bit du même mot de passe que vous pouvez récupérer par la suite, ou bien vous pouvez obtenir un mot de passe aléatoire tout le temps. L'utilisation générale est:

md5pass [password] [salt]

où password est un mot choisi qui sera utilisé pour la construction de la chaîne aléatoire et salt est 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" à utiliser. Si vous n'utilisez pas de salt, vous ne pourrez peut-être pas recréer cette même chaîne par la suite.

Cependant, si vous utilisez un salt comme ceci:

md5pass Word 512 $1$512$.0jcLPQ83jgszaPT8xzds0

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

Pablo Repetto · Answer

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

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

Le générateur de mot de passe nécessite un fichier_avec_caractères contenant tous les caractères que vous souhaitez que le mot de passe utilise, un caractère par ligne et exactement une fois chacun. Le fichier ne doit pas contenir de lignes vides et les lignes doivent se terminer par une nouvelle ligne.

Le générateur de phrase secrète nécessite un fichier_avec_mots contenant tous les mots que vous souhaitez utiliser dans la phrase secrète, un mot par ligne et exactement une fois chacun. Le fichier ne doit pas contenir de lignes vides et les lignes doivent se terminer par une nouvelle ligne.

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

Bruno Bronosky · Answer

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

/dev/urandom est un flux de aléatoire "octets" (qui inclut des caractères non imprimables)
base64 code les données en octets [A-Za-z0-9/+] (qui est entièrement imprimable)
dd copie l'entrée dans la sortie en appliquant les modificateurs donnés en arguments (qui peuvent 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 tube.
- Ex: tr -d '[A-Z/+]' pour se débarrasser des majuscules et + et /
Vous pouvez définir la bs (taille de bloc) à la longueur dont vous avez besoin.
Sous Linux, base64 revient à 76 colonnes par défaut et doit être réinitialisé avec -w0 sauf si vous le voulez.

Jake · Answer

J'ai trouvé que le piping/dev/urandom vers tr sur macOS ne fonctionnait pas. Voici une autre façon:

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

Sharuzzaman Ahmat Raslan · Answer

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, changez le nombre dans la commande cut en la longueur dont vous avez besoin, 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 autre tr

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

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

Iiridayn · Answer

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és et retapés comme 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 à taper et mémorable
il utilise des outils système standard - pas de binaires supplémentaires
ne "gaspille" pas beaucoup de caractère aléatoire (utilise 89% des bits aléatoires qu'il reçoit vs ~ 24% pour les solutions directement connectées à tr)
22 et 44 caractères se combinent assez bien (juste au-dessus même) 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
plus courtes que les solutions codées hexadécimales (32 et 64 au lieu de 22 et 44) telles que md5sum/sha1sum, etc.

Nous remercions https://unix.stackexchange.com/a/230676/958 et surtout les commentaires pour mon inspiration initiale.

Nicolae Iotu · Answer

Jusqu'à présent, aucune des réponses n'est vraiment multi-OS.

Les principaux défauts sont représentés par la définition des paramètres régionaux (cas MacOS) et tr ne pouvant pas reconnaître les intervalles de caractères (cas Solaris).

Vous devriez essayer shlibs . C'est frais et vraiment multi-OS. Le code pour obtenir une chaîne aléatoire est shlibs str005 (./shlibs str005).

Obtenez une chaîne aléatoire de 50 caractères, incluez la ponctuation, excluez les nombres:

shlibs str005 50 -p -xd

Zibri · Answer

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 bien, pour générer plusieurs mots de passe:

chat/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*

Un 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

Stuart Cardall · Answer

Je maintiens secpwgen dans Alpine Linux & je garde les sources sur mon Github .

Il peut produire des chaînes aléatoires ou des phrases de dés:

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 Diceware:

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.