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

209

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

Landroni
la source
1
Il y a déjà de bonnes réponses à AskUbuntu . (J'utilise apgpersonnellement.)
Sparhawk
1
@Sparhawk La question / réponses AskUbuntu concerne davantage les outils de référencement. S'il vous plaît, envisagez d'ajouter une réponse ici indiquant comment utiliser apgpour générer une chaîne aléatoire.
landroni
1
Soyez prudent lorsque vous utilisez la génération de nombres aléatoires sur des ordinateurs. Certains sont beaucoup moins aléatoires qu'ils ne le paraissent, mais il est assez difficile de faire la différence entre une «bonne» et une «mauvaise» génération de nombres aléatoires.
Sobrique
@Sobrique Excellent point sur les générateurs de nombres pseudo-aléatoires (par exemple /dev/urandom). Ce serait bien d'avoir des réponses en utilisant de vrais générateurs de nombres aléatoires, basés par exemple sur random.org .
landroni
25
Réponse blague: Pour générer une chaîne réellement aléatoire, placez un nouvel utilisateur devant Emacs (ou Vim) et demandez-lui de quitter. ;)
Wildcard

Réponses:

187

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
herbert
la source
15
Ou faites ceci: head /dev/urandom | tr -dc A-Za-z0-9 | head -c10- Cette façon est plus précise. Vous obtenez 10 caractères en majuscules, en majuscules ou en chiffres
Brandin, le
8
La première headcommande pourrait être problématique. Il affichera les 10 premières lignes à partir de /dev/urandom, ce qui signifie qu'il s'arrêtera une fois qu'il aura vu la 10e nouvelle ligne. La longueur de la sortie envoyée à la trcommande est donc aléatoire. Il est possible que la sortie contienne moins de 13 caractères tr. Je n'ai pas calculé la probabilité que cela se produise, les calculs sont un peu délicats.
Kasperd
6
Mieux vaut le faire comme ça:<dev/urandom tr -dc "$charset" | head -c "$length"
PSkocik
3
+1 Voici une tentative rapide pour inclure les autres caractères de la page des caractères spéciaux du mot de passe OWASP , échappée pour la ligne de commande bash:tr -dc A-Za-z0-9\!\"#$\&\'\(\)\*+,-./\:\\\\\;\<=\>\?@[]^_`{\|}~
Rup
2
@Rup Je ne suis pas sûr que ce qui ne fonctionne pas avec votre tr ..commande, mais simplement citer tout (sauf la citation simple) fonctionne - tr -dc 'A-Za-z0-9!"#$%&'\''()*+,-./:;<=>?@[\]^_`{|}~'.
Kenny Evitt
144

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
Landroni
la source
21
+1 pour ne pas réinventer la roue. Si vous ne voulez pas l'entropie réduite de la contrainte "prononçable", utilisez simplement pwgen -s.
Nate Eldredge le
123

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

openssl rand -base64 12

ou

openssl rand -hex 12
400 le chat
la source
10
rand -hexlimitera la sortie à 16 caractères au lieu des 90+ de mon clavier. base64 est préférable car il comporte 64 caractères, mais ce n'est pas aléatoire (par exemple, il existe des motifs de remplissage prévisibles, et peut-être que certains caractères apparaissent plus souvent que d'autres).
Martin Tournoij
@Carpetsmoker: notez que l'exemple openssl rand -base64 12génère 16 caractères de sortie (car 256 valeurs sont mappées sur 64). Et l'exemple hexagonal produit 24 caractères. Il n'y a pas de perte dans le cas de l'hex car c'est un simple mappage 1: 2, mais il pourrait y en avoir un peu dans le cas en base64 puisque le remplissage est utilisé. La base n’affecte pas l’aléatoire, c’est la façon dont l’on mappe l’un sur l’autre. (et le nombre total de bits est beaucoup plus important).
Dennis Williamson
La question était "Comment générer une chaîne aléatoire d'une longueur spécifique" @DennisWilliamson, alors même si votre commentaire est correct en tant que tel , il ne l'est pas dans le contexte de cette question .
Martin Tournoij
@Carpetsmoker: Dans ce cas, ce n'est pas non plus la réponse.
Dennis Williamson
4
Cette réponse mérite plus de votes positifs. urandom, pwgen, gpw, etc. peuvent ou non être disponibles sur votre système; également dans des environnements différents, une politique qui fonctionne sur un peut ne pas fonctionner sur un autre. Ce serait une jolie configuration dysfonctionnelle de ne pas avoir OpenSL. Encore mieux: openssl rand -base64 32 | tr -d / = + | cut -c -16 Cela vous donnera 32 caractères moins les caractères non alphanum et ajustés à une longueur de 16 caractères. Le rend facile à traiter en tant qu'administrateur. Les utilisateurs n'ont que des alphanums (qu'ils ont tendance à apprécier). La longueur est suffisamment longue pour que la suppression des caractères spéciaux n’impacte pas trop l’entropie. D'or.
zentechinc
18

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
x1b2j
la source
1
+1 Cette réponse est POSIXly correcte, moins l'utilisation /dev/urandomde bien sûr
Harold Fischer
12

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:]).

drws
la source
1
En quoi est-ce différent des réponses existantes? Plus précisément, ce herbert vient à l' esprit.
Fox
3
@Fox Sa solution utilise une liste de caractères codée en dur, ce qui n'est pas une pratique de programmation encouragée en raison de la lisibilité du code, de sa compacité et de sa propreté. De plus, certains des caractères ASCII imprimables spéciaux pourraient être interprétés par bash, sans oublier l’inconvénient le plus évident de son unique doublure: si l’entropie maximum est souhaitée, peut-on être sûr que tous les caractères disponibles sont inclus dans la liste? Et qu'il n'y a pas de doublons qui pourraient éventuellement altérer le comportement du tr? Sa réponse devrait être remplacée par la mienne puisque vous avez demandé :)
drws
2
La plupart des sites Web, sinon la plupart, ont des restrictions sur les caractères pouvant figurer dans un mot de passe. Par conséquent, coder en dur '[: print:]' ne me semble pas meilleur que coder en dur la liste des caractères spéciaux du mot de passe OWASP. Je pense que presque chaque réponse ici pourrait être améliorée en utilisant une variable, mais c'est un changement tellement mineur que je ne suggérerais qu'une modification
Fox
1
< /dev/urandom tr -cd '[:graph:]'| tr -d '\\' | head -c 32; echosi vous ne voulez pas ` characters in generated string. `parce que c'est un caractère d'échappement dans de nombreuses langues pose des problèmes
mzzzzb
< /dev/urandom tr -cd "[:print:]" | tr -d ' \\/\`\|' | head -c 32; echoexclure | \ / `et l'espace
Ryan Krage
9

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.

terdon
la source
Comment contrôlez-vous la longueur de la chaîne générée?
Landroni
@landroni Je ne pense pas que vous puissiez utiliser une boucle tant que vous n'avez pas atteint la bonne longueur. $RANDOMimprimera un nombre compris entre 0 et 32767.
terdon
J'ai essayé d'exécuter la commande une vingtaine de fois et je ne peux jamais obtenir plus de 4 ou 5 caractères ...
landroni
2
@landroni merci, j'ai ajouté un moyen de spécifier la longueur mais ce n'est pas très bon. Je voudrais juste utiliser quelque chose comme à la rand=$(head -c 100 /dev/urandom | tr -dc A-Za-z0-9 | head -c13)place.
terdon
1
@SkippyleGrandGourou très bon point. J'ai ajouté ceci à la réponse, merci.
terdon
8

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é.

entwicklerseite
la source
5

@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
douteux
la source
Pour une raison quelconque, la iconvsolution utilise au maximum un cœur de processeur et ne génère pas de sortie (j'ai attendu 10
secondes
Sur mon système Ubuntu 14.04, iconv est fourni par la libc-bin2.19. Je ne sais pas si c'est la même icône ...
landroni
trprend en charge l'entrée binaire. Cependant, une plage similaire A-Zpeut être influencée par les paramètres régionaux. EssayezLC_ALL=C tr …
Gilles
1
@Gilles Selon la spécification POSIX, il ne "prend pas en charge les entrées binaires". Seul GNU le trfait car il ne supporte pas du tout le multi-octets (par exemple, la dernière fois que j’ai vérifié que le changement de casse avait été implémenté en définissant simplement le sixième bit de chaque octet). D'autres systèmes (par exemple, BSD) prennent en charge plusieurs octets, ce qui échouera car le risque qu'un flux d'entrée aléatoire soit également un flux valide à plusieurs octets est très faible dans la plupart des encodages. GNU peut ajouter un support multi-octets à tout moment, auquel cas cela échouera. Bien sûr, le réglage LC_ALL=Cva résoudre ce problème.
Martin Tournoij
@Carpetsmoker POSIX nécessite trde traiter les entrées binaires (dans les paramètres régionaux C). (Bon, ok, ça dit seulement explicitement que les octets nuls doivent être supportés, cela ne dit pas que les fichiers non vides ne se terminant pas par un caractère de nouvelle ligne doivent être supportés, mais en pratique, c'est toujours le cas également.)
Gilles
4

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.

Sandburg
la source
1
Voici les options pour générer des mots de passe aléatoires de 14 lettres contenant de nombreux caractères spéciaux:apg -a1 -m14
neuhaus
3

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]

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.

Joke Sr. OK
la source
Quand a saltest utilisé, cela ressemble à l'approche de PasswordMaker ...
landroni
-Oui Peut sembler similaire à un mot de passe de fabricant, mais la différence est qu'il ne s'agit ni d'un programme commercial ni d'aucun autre logiciel, car l'ensemble des outils md5, "md5pass, md5sum, md5sum.textutils", est concerné et est disponible, le système sans frais certains !!!
Joke Sr. OK
J'avais en fait à l'esprit PasswordMaker , qui est également open-source et non commercial.
Landroni
2

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.

Pablo Repetto
la source
1

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
Jake
la source
Vérifiez le dernier exemple de ma réponse. Il n'utilise pas tr. unix.stackexchange.com/a/494931/203075
Zibri le
1

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 2 (57 44 )> 256,64 bits d'entropie
  • 22 caractères me donne: log 2 (57 22 )> 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.

Iiridayn
la source
Si vous avez besoin chiffres / caractères spéciaux - en général , il y aura un certain nombre, sinon vous pouvez ajouter en toute sécurité 1sans réduire l' entropie (tout en générant un nouveau pour obtenir un w / plusieurs ne réduire l' entropie). Vous pouvez également ajouter en toute sécurité un !sans réduire l'entropie. Ni l'un ni l'autre des schémas n'augmente l'entropie, mais pourrait rendre la chaîne générée conforme aux anciennes exigences en matière de mot de passe.
Iiridayn
1

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.
Bruno Bronosky
la source
1

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

Sharuzzaman Ahmat Raslan
la source
0

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.
Stuart Cardall
la source
0

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
Zibri
la source
-1

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

camelCaseEnthusiast
la source
3
Si on me donnait la puissance de Python, je ne le ferais PAS de cette façon. Il serait beaucoup plus facile d’utiliser une jointure sur une chaîne contenant tous les caractères valides pour un mot de passe et d’utiliser random pour sélectionner les caractères.
Mike McMahon
préférable d'utiliser Python comme ceci code.activestate.com/recipes/578468-password-generator-mkpasswd
Grijesh Chauhan
-2

Je voudrais cette commande:

date +%s | sha256sum | base64 | head -c 12
Eugen Konkov
la source
1
Je préférerais utiliser une approche plus aléatoire en nanosecondes: étant date +%N donné que si vous générez de nombreux utilisateurs et mots de passe dans un script, les secondes pourraient devenir identiques pour de nombreuses ou même pour toutes les commandes de date, produisant ainsi des mots de passe identiques.
John Mayor
1
@JohnMayor: cette approche est plus robuste: dd if=/dev/random bs=512 count=1?
Eugen Konkov
8
Cette réponse est très dangereuse! Vous générez le ou les mots de passe à partir d'une graine connue, facile à prédire. Je pourrais générer tous les mots de passe générés à l'aide de cette méthode des dernières années et utiliser cette liste à des fins de forçage brutal.
Flux
-4

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.

KrazyKyngeKorny
la source
2
J'ai clarifié la question afin de préciser que les chaînes générées hors ligne sont préférables. La génération d'un mot de passe directement sur un site Web, en particulier si la connexion n'est pas HTTPS (comme dans votre réponse), n'est pas sécurisée.
landroni
1
Obtenir un mot de passe aléatoire sur Internet est spectaculaire- ment stupide et naïf. Quelqu'un connaît maintenant un mot de passe que vous utilisez pour un service ou un site et des informations personnelles uniques sur vous (adresse IP, informations du navigateur / de l'environnement). Ce site peut maintenant renvoyer les informations avec d’autres données collectées à votre sujet. Par exemple, une fois que vous avez posté sur une liste de diffusion, votre adresse IP figure dans l'en-tête de l'e-mail. Nous avons donc maintenant un mot de passe, un nom et une adresse e-mail ... Vous faites vraiment confiance à des inconnus au hasard avec votre mot de passe.
Martin Tournoij