<jupyter_start><jupyter_text>Protection des donnéesInternet est un monde **ouvert** où tout est accessible. Il est donc très important de protéger ses données **sensibles** (tout ce qui touche à votre vie privée). ![](https://upload.wikimedia.org/wikipedia/commons/thumb/a/a6/Anonymous_emblem.svg/480px-Anonymous_emblem.svg.png) Objectifs1. Comprendre le système de fichiers UNIX (MacOS X)1. Comprendre l'importance d'un bon mot de passe  (2) Les mots de passeIl sert à protéger ses données privées dans les réseaux sociaux, sur son téléphone portable, etc..  Pourquoi ?- le nom d'utilisateur peut être public- le mot de passe **DOIT** être secret Un bon mot de passeIl doit être difficile à trouver pour un être humain, mais surtout pour un ordinateur. L'[EPFL](https://wiki.epfl.ch/secure-it/questcequunbonmotdepasse) donne quatre caractéristiques pour un **bon mot de passe** :1. il n'est **pas basé sur un mot courant** (nom, prénom, etc..)1. il doit être **long**1. il ne doit pas contenir des **répétitions**1. il doit contenir des caractères **variés** (lettres, accents, chiffres, caractères spéciaux)Malheureusement, beaucoup de personnes ont encore des mots de passe trop simple  ExerciceRecherchez sur Internet quel est le mot de passe le plus utilisé pour les utilisateurs francophones  Qualité d'un mot de passeLe fichier ```dossier-a-cracker/passwords.txt``` contient les **20'000 mots de passes** les plus utilisés sur l'Internet francophone. Nous allons l'utiliser pour vérifier la qualité d'un mot de passe.L'instruction Python suivante permettent de stocker dans la **liste** ```passwords``` les 20'000 mots de passes du fichier ```dossier-a-cracker/passwords.txt```<jupyter_code>passwords = [line.rstrip() for line in open('dossier-a-cracker/passwords.txt', "r")]<jupyter_output><empty_output><jupyter_text>Accéder aux élément d'une listeL'opérateur de tranche `[m:n]` permet d'accéder à des sous ensembles- `[m:n]` de m jusqu'à (n-1)- `[:n]` du début jusqu'à (n-1)- `[m:]` de m jusqu'à la finUn index negatif compte depuis la fin  ExerciceA l'aide des opérateurs de tranche, répondez aux questions Affichez les cinq premiers mots de passe de la liste ```passwords```<jupyter_code>passwords[:5]<jupyter_output><empty_output><jupyter_text>Affichez le 1000ème mot de passe de la liste ```passwords``` Affichez les mots de passes entre 10'000 et 10'005 de la liste ```passwords``` Affichez l'avant dernier mot de passe de la liste ```passwords```  Vérifier si un mot est dans la listeL'opérateur `in` permet de verifier si un mot est dans une liste.Est-ce que le mot de passe `'<PASSWORD>'` est dans la liste ```passwords```?<jupyter_code>'iloveyou' in passwords
FIXME exemple False<jupyter_output><empty_output><jupyter_text>ExerciceVérifiez que le mot de passe ```cristiano7``` est dans la liste ```passwords``` Et le mot de passe ```C<PASSWORD>``` ?  Majuscule et minusculeLe mot de passe ```<PASSWORD>``` se trouve dans la liste ```passwords``` mais ```Cristiano7``` n'y est pas. Est-ce que rajouter une simple majuscule fait de mon mot de passe un bon mot de passe ?Python permet de mettre toutes les lettres en minuscules:<jupyter_code>'Cristiano7'.lower()<jupyter_output><empty_output><jupyter_text>et en majuscules:<jupyter_code>'Cristiano7'.upper()<jupyter_output><empty_output><jupyter_text>Tester un mot de passe 1. Avec l'opérateur ```in```, on peut vérifier qu'un élément existe dans une liste1. Avec les fonctions ```lower()``` et ```upper()``` on peut mettre une chaîne de caractères en majuscules et en minusculesil ne reste plus qu'à tester un mot de passe **inconnu** sur l'ensemble de la liste :L'algorithme est le suivant :FIXME- ```mdp_test``` <- entrée de l'utilisateur- pour tous les mots de passe ```mdp``` de la liste ```passwords``` :    - mettre ```mdp``` en minuscules    - mettre ```mdp_test``` en minuscules    - SI ```mdp_test``` égal à ```mdp``` ALORS le mot de passe existe    - SINON le mot de passe n'existe pas<jupyter_code>def mdp_existe_maj_min(mdp):
    if mdp.lower() in passwords:
        print(mdp,'existe dans la liste sous la forme', mdp.lower())
    else:
        print(mdp,'n\'existe PAS dans la liste')        
mdp_existe_maj_min('CrIsTiAno7')
'CrIsTiAno7'.lower in passwords<jupyter_output><empty_output><jupyter_text>ExerciceTestez avec cette fonction si les mots de passe suivants existent dans la liste ```passwords```:- ```'coucou2'```- ```'co<PASSWORD>'``` Avec une boucle, on peut tester n'importe quel mot de passe contre la liste ```passwords```.Testez vos mots de passe !(pour quitter, appuyez sur ENTREE<jupyter_code>mot = input('Entrez un mot de passe')
while len(mot) > 0:
    print(mot in passwords)
    mot = input('Entrez un mot de passe:')<jupyter_output>Entrez un mot de passe vincent<jupyter_text>Archive (ZIP) protégé par un mot de passeLe fichier ```confidentiel/mails_FBI.zip``` a été protégé contre l'extraction par un mot de passe. Si vous tentez d'extraire l'archive, vous devez fournir un mot de passe.Ces 4 lignes vont tester le mot de passe ```'jetaime'``` sur l'archive. Cela va créer une erreur de type :```RuntimeError: Bad password for file 'original/mails_FBI.txt'```<jupyter_code>from zipfile import ZipFile
with ZipFile('confidentiel/mails_FBI.zip') as file:
   mdp = 'jetaime' 
   file.extractall(pwd = bytes(mdp, 'utf-8'))<jupyter_output><empty_output><jupyter_text>Attaque en force bruteA partir de maintenant, on dispose de tous les outils pour attaquer en force brute l'archive ```'mails_FBI.zip'```. L'algorithme sera le suivant :1. pour tous les mots de passes ```mdp``` de la liste ```passwords``` FAIRE    1. Tester si le mot de passe est correct    1. SI le mot de passe est correct ALORS        1. le mot de passe a été trouvé. SORTIR    1. SINON        1. aller au mot de passe suivantLa fonction ```check_ret(mdp,archive)``` va tester un mot de passe ```mdp``` sur l'archive protégée ```archive``` et retourner la valeur ```0``` si le mot de passe est le bon<jupyter_code>import subprocess
def check_ret(mdp,archive):
    rc = -1
    p1 = subprocess.Popen(['unzip', '-t','-q', '-P', mdp,archive])
    p1.wait()
    rc = p1.returncode
    p1.kill()
    return rc<jupyter_output><empty_output><jupyter_text>Il est maintenant possible de tester tous les mots de passe de la liste sur une archive protégée par un mot de passe. Le fichier se trouve au chemin ```dossier-a-cracker/confidentiel/mails_FBI.zip```<jupyter_code>for mdp in passwords:
    ret = check_ret(mdp,'dossier-a-cracker/confidentiel/mails_FBI.zip')
    if ret == 0:
        print('Le mot de passe est :',mdp)
        break<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.11379414428010866, 'fraction_numerical': 0.009507998792635074, 'mean_word_length': 5.090992647058823, 'pattern_counts': {'":': 0, '<': 45, '<?xml version=': 0, '>': 45, 'https://': 2, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '10', 'dir': 'jupyter-structured-clean-dedup', 'id': '387852', 'license': 'MIT', 'n_tokens_mistral': 2369, 'n_tokens_neox': 2336, 'n_words': 814, 'path': 'doc/python/vi/5/Cracker_un_mot_de_passe.ipynb', 'repo_name': 'rasql/edunum', 'size': '6619'}