Faire un générateur de mot de passe en Python

Hacking éthique

Apprenez à faire un générateur de mot de passe en Python avec la possibilité de choisir la longueur de chaque type de caractère en utilisant les modules aléatoires, en chaîne et argparse intégrés.

Les générateurs de mots de passe sont des outils qui permettent à l’utilisateur de créer des mots de passe forts aléatoires et personnalisés en fonction des préférences.

Dans ce tutoriel, nous allons faire un outil de ligne de commande en Python pour générer des mots de passe. Nous utiliserons le module argparse pour faciliter l’analyse des arguments de ligne de commande que l’utilisateur a fournis. Commençons.

Importations

Importons quelques modules. Pour ce programme, nous avons juste besoin de la Classe ArgumentParser à partir de argparse et la random et secrets modules. Nous obtenons également le string module qui n’a que quelques collections de lettres et de chiffres. Nous n’avons pas à installer aucun de ceux-ci parce qu’ils viennent avec Python:

from argparse import ArgumentParser
import secrets
import random
import string

Mise en place de l’Argument Parser

Nous continuons maintenant à mettre en place l’argumente-analyse. Pour ce faire, nous créons une nouvelle instance de ArgumentParser à notre cours parservariable. Nous donnons à l’analyseur syntaxique un nom et une description. Ces informations apparaîtront si l’utilisateur fournit -h l’argumentation lors de l’exécution de notre programme, il leur dira également les arguments disponibles:

#Setting up the Argument Parser
parser = ArgumentParser(
    prog='Password Generator.',
    description='Generate any number of passwords with this tool.'
)

Nous continuons d’ajouter des arguments à l’analyseur syntaxique. Les quatre premiers seront le nombre de chaque type de caractères; nombres, minuscules, majuscules et caractères spéciaux, nous définissons également le type de ces arguments comme suit: int:

#Ajout des arguments à l'analyseur
parser.add_argument("-n", "--numbers", default=0, help="Number of digits in the PW", type=int)
parser.add_argument("-l", "--lowercase", default=0, help="Number of lowercase chars in the PW", type=int)
parser.add_argument("-u", "--uppercase", default=0, help="Number of uppercase chars in the PW", type=int)
parser.add_argument("-s", "--special-chars", default=0, help="Number of special chars in the PW", type=int)

Ensuite, si l’utilisateur veut à la place passer le nombre total de caractères du mot de passe, et ne veut pas spécifier le nombre exact de chaque type de caractère, alors le -t ou --total-length l’argument traite qui:

#ajouter un argument de longueur totale pw
parser.add_argument("-t", "--total-length", type=int, 
                    help="The total password length. If passed, it will ignore -n, -l, -u and -s, " \
                    "and generate completely random passwords with the specified length")

Les deux arguments suivants sont le fichier de sortie où nous stockons les mots de passe, et le nombre de mots de passe à générer. Le amount sera un nombre entier et le fichier de sortie est une chaîne (défaut):

#Le montant est un nombre, nous vérifions donc qu'il est de type int.
parser.add_argument("-a", "--amount", default=1, type=int)
parser.add_argument("-o", "--output-file")

Enfin, et ce n’est pas le moins important, nous a naparons la ligne de commande ment pour ces arguments avec le parse_args()méthode de la méthode ArgumentParserclasse. Si nous n’appelons pas cette méthode, l’analyseur ne vérifiera rien et ne soulèvera aucune exception :

#Analyse des arguments de ligne de commande.
args = parser.parse_args()

La boucle du mot de passe

Nous poursuivons avec la partie principale du programme : la boucle de mot de passe. Nous générons ici le nombre de mots de passe spécifiés par l’utilisateur.

Nous devons définir le passwordsliste qui contient tous les mots de passe générés:

#liste de mots de passe
passwords = []
#Parcourir la quantité de mots de passe.
for _ in range(args.amount):

Dans le for boucle, nous vérifions d’abord si total_length est passé. Si c’est le cas, alors nous générons directement le mot de passe aléatoire en utilisant la longueur spécifiée:

if args.total_length:
    #générer un mot de passe aléatoire avec la longueur
    #de total_length basé sur tous les caractères disponibles
    passwords.append("".join(
        [secrets.choice(string.digits + string.ascii_letters + string.punctuation) \
            for _ in range(args.total_length)]))

Nous utilisons le module secrets au lieu du hasard afin que nous puissions générer des mots de passe aléatoires cryptographiquement forts.

Sinon, nous faisons un passwordliste qui conservera d’abord toutes les lettres possibles, puis la chaîne de mot de passe:

    else:
        password = []

Maintenant nous ajoutons les lettres possibles, les chiffres, et les caractères spéciaux à la passwordliste. Pour chacun des types, nous vérifions s’il est passé à l’analyseur syntaxique. Nous recevons les lettres respectives du module string:

#Si/combien de chiffres le mot de passe doit contenir 
   for _ in range(args.numbers):
      password.append(secrets.choice(string.digits))

#Si/combien de caractères majuscules le mot de passe doit contenir  
   for _ in range(args.uppercase):
     password.append(secrets.choice(string.ascii_uppercase))
        
#Si/combien de caractères minuscules le mot de passe doit contenir  
   for _ in range(args.lowercase):
     password.append(secrets.choice(string.ascii_lowercase))

#Si/combien de caractères spéciaux le mot de passe doit contenir   
   for _ in range(args.special_chars):
     password.append(secrets.choice(string.punctuation))

Ensuite, nous utilisons la fonction random.shuffle() pour mélanger la liste. C’est ce qui est en place:

#Mélangez la liste avec toutes les lettres, chiffres et symboles possibles.
random.shuffle(password)

Après cela, nous rejoignons les personnages résultants avec une corde vide ""Nous avons donc la version corde de celui-ci:

#Récupérez les lettres de la chaîne jusqu'à l'argument de longueur, puis joignez-les.
password = ''.join(password)

Enfin, et ce n’est pas le moins important, nous ajoutons ceci password à la passwordsliste.

#ajoutez ce mot de passe à la liste globale des mots de passe.
passwords.append(password)

Sauver les mots de passe

Après la boucle de mot de passe, nous vérifions si l’utilisateur a spécifié le fichier de sortie. Si c’est le cas, nous ouvrons simplement le fichier (qui sera fait s’il n’existe pas) et écrivons la liste des mots de passe :

#Stockez le mot de passe dans un fichier .txt.
if args.output_file:
    with open(args.output_file, 'w') as f:
        f.write('\n'.join(passwords))

Dans tous les cas, nous imprimons les mots de passe.

print('\n'.join(passwords))

Exemples

Maintenant, utilisons le script pour générer différentes combinaisons de mots de passe. Tout d’abord, imprimons l’aide :

$ python password_generator.py --help
usage: Password Generator. [-h] [-n NUMBERS] [-l LOWERCASE] [-u UPPERCASE] [-s SPECIAL_CHARS] [-t TOTAL_LENGTH]
                           [-a AMOUNT] [-o OUTPUT_FILE]

Generate any number of passwords with this tool.

optional arguments:
  -h, --help            show this help message and exit
  -n NUMBERS, --numbers NUMBERS
                        Number of digits in the PW
  -l LOWERCASE, --lowercase LOWERCASE
                        Number of lowercase chars in the PW
  -u UPPERCASE, --uppercase UPPERCASE
                        Number of uppercase chars in the PW
  -s SPECIAL_CHARS, --special-chars SPECIAL_CHARS
                        Number of special chars in the PW
  -t TOTAL_LENGTH, --total-length TOTAL_LENGTH
                        The total password length. If passed, it will ignore -n, -l, -u and -s, and generate completely   
                        random passwords with the specified length
  -a AMOUNT, --amount AMOUNT
  -o OUTPUT_FILE, --output-file OUTPUT_FILE

Un lot à couvrir, en commençant par le --total-length ou -t paramètre:

$ python password_generator.py --total-length 12
uQPxL'bkBV>#

Cela a généré un mot de passe d’une longueur de 12 et contient tous les caractères possibles. Bon, générons 10 mots de passe différents comme ça :

$ python password_generator.py --total-length 12 --amount 10
&8I-%5r>2&W&
k&DW<kC/obbr
=/'e-I?M&,Q!
YZF:Lt{*?m#.
VTJO%dKrb9w6
E7}D|IU}^{E~
b:|F%#iTxLsp
&Yswgw&|W*xp
$M`ui`&v92cA
G3e9fXb3u'lc

C’est génial. Générons un mot de passe avec 5 caractères minuscules, 2 majuscules, 3 chiffres et un caractère spécial, un total de 11 caractères:

$ python password_generator.py -l 5 -u 2 -n 3 -s 1
1'n3GqxoiS3

Bon, générer 5 mots de passe différents basés sur la même règle:

$ python password_generator.py -l 5 -u 2 -n 3 -s 1 -a 5
Xs7iM%x2ia2
ap6xTC0n3.c
]Rx2dDf78xx
c11=jozGsO5
Uxi^fG914gi

C’est génial. On peut aussi générer des broches aléatoires de 6 chiffres:

$ python password_generator.py -n 6 -a 5 
743582
810063
627433
801039
118201

Ajout de 4 majuscules et sauvegarde dans un fichier nommé keys.txt:

$ python password_generator.py -n 6 -u 4 -a 5 --output-file keys.txt
75A7K66G2H
H33DPK1658
7443ROVD92
8U2HS2R922
T0Q2ET2842

Un nouveau fichier keys.txt apparaîtra dans le répertoire de travail actuel qui contient ces mots de passe, vous pouvez générer autant de mots de passe que vous le pouvez:

$ python password_generator.py -n 6 -u 4 -a 5000 --output-file keys.txt

Conclusion

Excellente. Vous avez réussi à créer un générateur de mot de passe en utilisant du code Python. Voyez comment vous pouvez ajouter d’autres fonctionnalités à ce programme.

Pour les longues listes, vous voudrez peut-être ne pas imprimer les résultats dans la console, de sorte que vous pouvez omettre la dernière ligne du code qui imprime les mots de passe générés sur la console.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *