Dans cet exercice, vous allez développer un système simplifié de gestion de comptes utilisateurs sécurisés.
Chaque compte :

• doit avoir un identifiant unique, un mot de passe stocké de manière sécurisée et un niveau d'accès,

• doit pouvoir accéder à un ensemble de chiffrements et de déchiffrements pour gérer des messages sensibles,

• doit pouvoir vérifier l'intégralité des données avec un hash.

Pour cela, trois fichiers python différents vont être considérés :

• Un fichier outils.py permettant de valider les mots de passe et de les hacher.

• Un fichier classes.py contenant les différentes classes du mini-projet : Utilisateur, CodageCesar et CodageXOR.

• Un fichier principal main.py utilisant les fichiers précédents pour gérer des comptes sécurisés.

Partie A : hachage de mots de passe sûrs

Afin d'augmenter fortement le temps nécessaire pour déchiffrer un mot de passe par une attaque par force brute, la première mesure de sécurité est d'imposée des critères sur le mot de passe choisi par les utilisateurs :

• Le mot de passe doit contenir au moins 12 caractères.

• Le mot de passe doit contenir au moins 1 lettre majuscule.

• Le mot de passe doit contenir au moins 1 lettre minuscule.

• Le mot de passe doit contenir au moins 1 chiffre.

• Le mot de passe doit contenir au moins 1 caractère spécial de cette chaîne : "!@#$%^&*()_+-=[]{}|;:,.<>?/".

1. Dans un fichier à créer nommé outils.py, proposer une fonction valider_mdp qui prend en paramètre une chaîne de caractères correspondant à un mot de passe que voudrait prendre un utilisateur et qui renvoie un booléen True si ce mot de passe rempli les 5 critères précédents et False sinon.

   Vous pouvez vous aider du code à trous proposé dans cet autre exercice traitant de la cybersécurité.

2. Tester la fonction valider_mdp créée avec ce jeu de tests :

   def tests_valider_mdp():
       assert valider_mdp("1_tropCourt") == False, "erreur sur un mot de passe trop court"
       assert valider_mdp("Un_sans_chiffre") == False, "erreur sur un mot de passe sans chiffre"
       assert valider_mdp("1_sans_chiffre") == False, "erreur sur un mot de passe sans majuscule"
       assert valider_mdp("1_SANS_MINUSCULE") == False, "erreur sur un mot de passe sans minuscule"
       assert valider_mdp("1SansCaractereSpecial") == False, "erreur sur un mot de passe sans caractère spécial"
       assert valider_mdp("Enf1!T@nt_DAttempte...") == True, "erreur sur un mot de passe convenable"
       print("tests sur valider_mdp réussis !")                        

Afin de ne pas stocker en clair les mots de passe, la technique du hachage va être utilisée.
Celle-ci consiste à transformer une donnée telle un mot de passe en une chaîne de caractères de taille fixe appelée empreinte (ou hash en franglais) à l'aide d'une fonction de hachage.
Vous trouverez dans cet autre exercice de cybersécurité des détails sur ce qu'est une fonction de hachage.
Dans ce mini-projet, nous travaillerons avec la fonction de hachage la plus utilisée actuellement en cybersécurité : la SHA-256.

Cependant, utiliser un standard de cybersécurité ne suffit pas pour se prémunir d'attaques !
En effet, comme une fonction de hachage transforme toujours le même mot donné en entrée en la même empreinte, il suffit à un pirate informatique de calculer en avance l'empreinte de millions de mots de passe "courants", de stocker ces associations "mot_de_passe": "empreinte" dans un dictionnaire puis de chercher dans ce dictionnaire si une empreinte volée ou interceptée y apparaît et ainsi pouvoir connaître le mot de passe en clair.
Ce type d'attaque s'appelle table arc-en-ciel (ou Rainbow table en franglais).

Pour éviter ce type d'attaque, une chaîne de caractères aléatoire, appelée sel, est rajouté par concaténation au mot de passe choisi avant le hachage.
Comme l'empreinte de deux mots proches donnés en entrée sont très dissemblables, une table arc-en-ciel devient inopérante.

3. Dans le même répertoire outils.py, recopier et compléter la fonction creer_sel suivante qui prend en paramètre un entier long et qui renvoie une chaîne de caractères formées de long caractères choisis aléatoirement dans un ensemble de possibles.

   import random
   
   caracteres = "azertyuiopqsdfghjklmwxcvbnAZERTYUIOPQSDFGHJKLMWXCVBN0123456789"
   lst = [... for ... in ...] # liste des caractères de la chaîne caracteres
   def creer_sel(long: int) -> str:
   	ch = ""
   	for _ in range(long):
   		carac = random.choice(lst)
   		...
   	return ch

4. En cybersécurité, il suffit d'associer à chaque utilisateur un sel fixe, qu'il est même possible de stocker en clair.

   Dans le fichier outils.py, proposer une fonction rajout_sel qui prend en paramètre un dictionnaire et une chaîne de caractères correspondant à un utilisateur, qui vérifie si cet utilisateur apparaît comme clé dans ce dictionnaire et sinon calcule une clé aléatoire de longueur 10 servant de sel pour cet utilisateur puis rajoute dans ce dictionnaire l'association "nom_utilisateur": "sel_obtenu".
   Cette fonction renvoie finalement le dictionnaire éventuellement modifié.

5. Au vu de l'importance du hachage, une librairie native de Python contient les fonctions utiles pour de tels hachages dans la bibliothèque hashlib.
   Le script suivant permet de renvoyer l'empreinte en hexadécimal de la concaténation des deux chaînes de caractères données comme argument en utilisant la fonction SHA-256 :

   # Ne pas oublier d'importer d'abord la bibliothèque hashlib ! 
   def saler_hasher_mdp(mot_de_passe: str, sel: str) -> str:
       return hashlib.sha256((mot_de_passe + sel).encode()).hexdigest()  

   Dans le fichier outils.py, à l'aide des fonctions précédentes, créer une fonction hacher qui a trois paramètres :

   • nom_utilisateur : une chaîne de caractères identifiant un utilisateur.

   • dico_sel : un dictionnaire qui à chaque utilisateur connu par son nom associe son sel.

   • mot_de_passe : chaîne de caractères que l'utilisateur aimerait utiliser comme mot de passe.

   Cette fonction vérifie que le mot de passe proposé valide les 5 critères vus au début. Dans ce cas, l'empreinte de la concaténation du mot de passe avec le sel de l'utilisateur est créée et renvoyée. Sinon, rien n'est renvoyée.
   On suppose ici que le nom de l'utilisateur apparaît bien comme clé du dictionnaire, mais écrire une précondition le vérifiant.

Partie B

Le but est de créer un fichier classes.py dans le même répertoire que le précédent outils.py est de le compléter au fur et à mesure afin qu'il puisse gérer les instances d'utilisateurs et des instances de textes à chiffrer ou déchiffrer suivant deux moyens simples.

1. Rajouter dans le fichier outils.py la ligne suivante donnant en clair le sel associé à deux utilisateurs :

   dico_sel = {"utilisateur1" : "AXi8g22CAN", "utilisateurB@c": "3VD7SFitP9"}

   Tout au long de cette partie, c'est ce dictionnaire qui sera appelé pour obtenir le sel associé à un utilisateur donné.
   On supposera aussi que l'identifiant de l'utilisateur est toujours présent dans ce dictionnaire (pour ne pas avoir à utiliser la fonction rajout_sel).

   Importer en une ligne le contenu du fichier outils.py dans classes.py.

La classe nommée Utilisateur possède trois attributs :

• id : une chaîne de caractères identifiant de manière unique un utilisateur.

• __hache : chaîne de caractères correspondant à l'empreinte du mot de passe de l'utilisateur considéré

• niveau_acces : chaîne de caractères correspondant au statut de l'utilisateur : "admin" ou "user" ou "". Le statut "" empêche toute action de l'utilisateur sur le site.

Le constructeur de la classe Utilisateur a trois paramètres particuliers :

• id, l'identifiant supposé unique de l'utilisateur

• mot_de_passe, la chaîne de caractères correspondant au mot de passe en clair que veut utiliser l'utilisateur.

• role, la chaîne de caractère correspondant au statut de l'utilisateur.

2. Dans classes.py, créer ce constructeur en faisant en sorte de récupérer le sel associé à l'utilisateur puis de hacher le mot de passe avec la fonction hacher de outils.py et d'affecter comme statut par défaut à l'utilisateur "user". Si le mot de passe n'est pas valide alors l'attribut __hache est initialisé tout comme niveau_acces à "".

3. Créer une instance de la classe Utilisateur pour l'utilisateur identifié par "utilisateur1" dont le nom est bien présent dans le dictionnaire d'association du fichier outils.py et dont le mot de passe voulu est "1mot2passe_PAS_sur?".
   De même, créer un second objet pour l'utilisateur "utilisateurB@c" avec comme mot de passe voulu "Mot2P@asse!".

4. Créer une méthode droits de la classe Utilisateur qui renvoie les droits sous forme d'une chaîne de caractères, droits correspondant au statut de l'utilisateur.

   Vérifier grâce à cette méthode le statut des deux objets précédemment construits.

5. Créer une méthode verifier_mdp de la classe Utilisateur qui prend en paramètre un chaîne de caractère correspond à un mot de passe et renvoie un booléen True dans le cas où l'empreinte calculée de ce mot de passe correspondant bien à l'empreinte associé à l'utilisateur considéré. Le renvoi est False sinon.

   Vérifier avec cette méthode que le mot de passe de l'utilisateur de pseudo "utilisateur1" est bien "1mot2passe_PAS_sur?".

6. Créer une méthode __str__ renvoyant une chaîne de caractères permettant d'obtenir un affichage clair :
   pour une instance objet de la classe Utilisateur identifié par "Cmoi!" et de statut "user", print(objet) conduit à l'affichage suivant :

   Utilisateur se nommant Cmoi! et ayant comme statut user.

La classe Caesar a un attribut cle (de type str) et permet de chiffrer ou de déchiffrer un texte à partir de cette clé.

7. Dans le fichier classes.py, créer la classe Caesar avec son constructeur.

8. Dans le fichier classes.py, recopier et compléter la méthode chiffrer suivante en supposant que texte est une chaîne de caractères écrite entièrement en majuscule :

       def chiffrer(self, texte: str) -> str:
           resultat = [] # stocke temporairement les caractères obtenus par chiffrement César
           for caractere in texte:
               resultat.append(chr((ord(...) - ... + ...) % 26 + ...))
           return ''.join(resultat) # permet de créer rapidement une chaîne de caractères formée des éléments ordonnés de la liste

   Voici différentes aides :

   • Rappel sur le chiffrement César.

   • Rappels sur la table ASCII.

   • chr(num) renvoie le caractère ASCII se trouvant en position num dans la table ASCII, num étant un nombre entier écrit en base 10.
     chr(65) renvoie le caractère "A".

   • ord(carac) renvoie la position décimale du caractère ASCII carac dans la table ASCII.
     ord("A") renvoie $65$.

   Vérifier qu'avec un décalage de $11$, le texte "GAZOPKHJZHHJ" est chiffré en "RLKZAVSUKSSU".

9. Le chiffrement de César est un chiffrement symétrique : la même clé est utile pour le chiffrement et le déchiffrement.
   Avec le code César, déchiffrer un texte qui a été chiffré avec une cle revient à chiffrer ce texte avec l'opposé de la clé de chiffrement.

   Rajouter la méthode dechiffrer de la classe Caesar qui prend en paramètre un texte chiffré de type str et renvoie le texte déchiffré.

10. Vérifier avec une chaîne quelconque de majuscules qu'avec les méthodes créées le déchiffrement annule bien le chiffrement.

XOR est une opération booléenne qui a déjà été vue dans un exercice de cybersécurité.
Il correspond sur les booléens au OU Exclusif : il ne renvoie True que lorsque les deux booléens sont différents.
Par analogie, entre deux bits, le XOR renvoie 1 si les deux bits diffèrent et 0 sinon. Voici comme appliqué un XOR indirectement entre une chaîne de caractères et un autre caractère :

• Chacun des caractères peut être converti en un entier, celui correspondant à la position de ce caractère dans la table ASCII. C'est par exemple le rôle de la fonction python ord.

• Ensuite, chacun de ces nombres peut être converti en binaire.

• Puis le XOR s'applique bit à bit sur ces conversions binaires.

• Enfin, le résultat obtenu binaire obtenu et converti par bloc de 7 bits en un nombre entier entre 0 et 127, nombre qui lui correspond finalement à un caractère ASCII.
  C'est ce caractère qui est renvoyé comme transformation des deux caractères initiaux.
  En appliquant ce procédé à chaque caractère et en concaténant, on obtient la transformation d'une chaîne de caractères par un autre caractère avec un XOR interne.

Le XOR est implémenté en Python directement avec l'opérateur ^, sur les entiers et les bits, mais pas sur les caractères.

11. Dans le fichier classes.py, créer une classe XOR, avec son constructeur, dont l'unique attribut cle est un entier compris entre 0 et 127.
    Cette clé correspond à la position d'un caractère dans la table ASCII.

12. Créer l'instance liée à la clé 42.

13. Compléter la méthode xor_1carac qui prend en paramètre une chaîne de caractères texte et renvoie la chaîne obtenu en appliquant sur chacun de caractère de texte l'opération XOR avec la caractère correspondant à la clé de l'objet considéré, en ayant bien en tête que le XOR ^ ne s'applique qu'au niveau des entiers, pas des caractères.

        def xor_1carac(self, texte: str ) -> str:
            lst = [chr(...) for carac in texte] # liste des caractères ASCII obtenus par XOR
            return ''.join(lst)                 # chaîne créée par concaténation directe des caractères de la liste

    Vérifier que lorsque la clé choisie est $42$, la chaîne de caractères "Oasis_@" est transformée en "eKYCYuj"

14. Rendre désormais privée la méthode xor_1carac.

    Créer une méthode chiffrer de la classe XOR qui prend en paramètre une chaîne de caractères texte, utilise la méthode privée précédente et renvoie la chaîne de caractères obtenues.

Le chiffrement par XOR est aussi un chiffrement symétrique : la même clé permet à la fois de chiffrer et de déchiffrer en utilisant la propriété suivante sur les caractères ASCII $a$ et $b$ : $$(a \wedge b) \wedge b = a$$

15. Créer une méthode dechiffrer qui prend en paramètre une chaîne texte et renvoie la chaîne obtenue par application du XOR avec la clé de l'instance considérée.

16. Vérifier sur une chaîne de caractères quelconques que le déchiffrement annule bien le chiffrement.

Partie C

Les deux fichiers déjà créés vont être utilisé dans un troisième fichier main.py qui sert de fichier de travail.
L'idée est de limiter l'accès direct des utilisateurs à ce seul fichier : toutes les interactions s'y situent.
Pour cela, on commence par modifier les deux fichiers sources afin que les tests présents dans ces fichiers ne soient pas exécutés au moment de l'importation des fonctions et des classes.
Ensuite, on créé deux nouveaux utilisateurs directement dans le fichier main.py puis on interagit dessus pour authentifier et dé-chiffrer.

1. Dans le fichier classes.py, rajouter en toute fin ce bloc :

   if __name__ == "__main__":

   Déplacer dans ce bloc tous les instances crées dans la partie B ainsi que les tests effectués dessus.

   Ce déplacement permet de pouvoir toujours lancer ces tests depuis le fichier classes.py : si vous exécutez le script directement, vous voyez apparaître les résultats des tests.
   Cependant, si vous importez ce script dans un autre fichier, ces tests ne sont pas exécutés.

2. Dans le fichier outils.py, au niveau du corps principal, rajouter dans le dictionnaire dico_sel les deux associations suivantes :

   "admin123!": "J9ysNu9Pjt", "azerty007": "IDB40mFq7c"

3. Créer dans le même répertoire que les deux fichiers précédents le fichier main.py.
   En une seule ligne, importer dans ce nouveau fichier les trois classes Utilisateur, Caesar et XOR du fichier classes.py.

4. Dans ce répertoire main.py, créer deux nouveaux utilisateurs :

   • admin identifier par le nom "admin123!" voulant comme mot de passe "A1Z2E3R4t5y6:000!".

   • user3 identifier par le nom "azerty007" voulant comme mot de passe "^K1o#R53tFq/c5PWk3".

5. Proposer deux tests d'authentification :

   • Une personne se prétendant nommée "admin123!" avec pour mot de passe saisi : "A1Z2E3R4t5y6:000!".
     Quel script utilisant une méthode précédemment écrite permet d'authentifier ou non cette personne ?

   • Une personne se prétendant nommée "azerty007" avec pour mot de passe saisi : "^K1o#R63tFq/c5PWk3".
     Quel script utilisant une méthode précédemment écrite permet d'authentifier ou non cette personne ?

6. Afficher les informations connues sur l'utilisateur admin.

7. Quel script permet de chiffrer le texte "BONJOURTOUTLEMONDE" avec un décalage de 17 en César ?

8. Quel script permet de déchiffrer le texte "uWLg\]ghYKK]g{WUHJWUQKT]g[PYV_]Jg]VgLWML]gMJ_]V[]" avec un XOR de clé $56$ ?