+|title|date|+|---|---|+|TP Cryptologie|2021|++|authors|+|---|+|Clarisse 'Nyota' BLANCO|+|Dorian 'Renji' PÉRON|++# **Le chiffre de César**++_Prérequis : la table ASCII, modulo_++## Un peu d'histoire++---+Ce moyen de chiffrement doit son nom à Jules César, célèbre homme d'état romain. Il aurait utilisé pour certaines de ses communications secrètes, militaires notamment, un chiffrement par substitution. Celui-ci utilisant un décalage d'une valeur trois.++## Qu'est-ce qu'un chiffrement par substitution ?++---+Pour faire simple, cette méthode consiste à substituer la valeur d'une lettre par une lettre, un chiffre ou autre. Dans le cas du chiffrement de César, on substitue une lettre par une autre lettre. Par exemple, si l'on décide d'effectuer un décalage de trois, voici comment la valeur de chaque lettre va évoluer :++![Image not loading](imgs/shifting.jpg)++Voilà comment cela va se répercuter sur l'alphabet tout entier :++| |Substitution avec un décalage de 3|+|---|---|+|Alphabet|A B C D E F G H I J K L M N O P Q R S T U V W X Y Z|+|Substitution|D E F G H I J K L M N O P Q R S T U V W X Y Z A B C|++On observe donc que A (première lettre de l'alphabet) sera encodée par D (troisième lettre de l'alphabet), que B sera encodée par E, que C par F, etc. On remarque que X sera codé par A, Y par B et Z par C. Si le chiffre donné pour le décalage fait dépasser de l'alphabet, on revient au début.++Par exemple, Z est la 26ème  lettre de l'alphabet. Si l'on applique un décalage de deux, on a alors : 26 + 3 = 29. C'est plus qu'il n'y a de lettres dans l'alphabet. Pour revenir au début, il n'y a qu'à soustraire le nombre total de lettres dans l'alphabet : 29 - 26 = 3. La troisième lettre de l'alphabet est C. Z est donc codé par C.++D'autres exemples:++>Décalage de trois : **Girls Can Code!** devient **Jluov Fdq Frgh!**++>Décalage de dix : **Hello World!** devient **Rovvy Gybvn!**++Voilà donc le principe de base du chiffrement de César.++## Place au code++---+Pour implémenter le chiffre de César, il va être plus simple de diviser le problème en deux parties. On peut en effet se dire que dans un premier temps, on va implémenter le chiffre de César pour qu'il ne soit appliqué que sur une lettre, puis ensuite appliquer cela à une chaîne de caractères. Pour l'instant, vous pouvez ne prendre en compte que les lettres majuscules ou minuscules si cela vous aide.++Ainsi, il va falloir implémenter les fonctions ```letterCaesar(l, d)``` et ```textCaesar(s, d)```.++### La fonction ```letterCaesar(l, d)```++Cette fonction va se charger d'appliquer le chiffre de César à seulement une lettre, elle va renvoyer un caractère. Elle prend en paramètre ```l``` qui correspond à la lettre sur laquelle on va appliquer le chiffrement, c'est un caractèrer. Quant au paramètre ```d```, il s'agit du décalage qui va être appliqué, c'est un nombre entier.+>**Bonus:** essayez de gérer les majuscules, minuscules ainsi que la ponctuation.++### La fonction ```textCaesar(t, d)```++Cette fonction va se charger d'appliquer le chiffre de César sur une chaîne de caractères, elle va renvoyer une chaîne de caractères. Elle prend en paramètre ```t``` qui correspond à une chaîne de caractères que l'on souhaite chiffrer. Elle prend également un autre paramètre ```d``` qui correspond au décalage qui doit être appliqué, c'est un nombre entier.++>**Tips :** pensez à prendre en compte les espaces, vous pouvez également utiliser des modulos si vous savez ce que c'est (en python, cela correspond à ```%```).++## Quelques fonctions et notions utiles++---++```py+# L'opérateur + permet, quand il est appliqué à des chaînes de caractères, de concaténer celles-ci. Exemples:++>>> 'Hello' + 'World'+'HelloWorld'+>>> 'O' + 'K'+'OK'+++# La fonction len() permet de connaître la longueur d'une chaîne de caractère.++>>> len('Hello World')+11+>>> s = 'ABCD'+>>> len(s)+4+++# Les fonctions ord() et chr() permettent de transformer un caractère en son code ASCII et vice-versa.++>>> ord('A')+65+>>> ord('C')+67+>>> chr(65)+'A'+++# La méthode upper() permet de tranformer une chaîne de caractères en majuscules.++>>> s = 'hello World'+>>> s.upper()+'HELLO WORLD'+>>> 'a'.upper()+'A'++# La méthode isalpha() permet de déterminer si un caractère est une lettre ou non.++>>> c = '!'+>>> c.isalpha()+False+>>> c = 'a'+>>> c.isalpha()+True+++# La méthode isupper() permet de savoir si un caractère est une majuscule ou non.++>>> c = 'G'+>>> c.isupper()+True+>>> c = "HELLO"+>>> c.isupper()+True+>>> c = 'g'+>>> c.isupper()+False+```++## Déchiffrer un message++---+Pour déchiffrer un message il suffit d'utiliser la clé inverse à celle utilisée pour chiffre. Par exemple:++```py+msg = stringCaesar("Hello World", 10)   # chiffre "Hello World", va donner "Rovvy Gybvn"+stringCaesar(msg, -10)                  # déchiffre msg, va donner "Hello World"+```++Dans un premier temps, testez avec votre code pour observer le résultat obtenu. Puis, adaptez votre code pour prendre en compte les décalages négatifs.++## Casser le chiffre de César++---+Il existe plusieurs méthodes pour casser le chiffre de César. On peut par exemple faire une analyse fréquentielle qui va compter la proportion de chaque lettre dans le message chiffré et comparer par rapport à la fréquence connue des lettres dans la langue du message. En Français, à titre d'exemple, la lettre 'e' est la plus fréquente, ainsi la lettre la plus fréquente du message chiffré doit sans doute correspondre à un 'e'. Cette méthode est très efficace sur les messages longs, le problème est donc que sur les messages dits courts, elle ne sera pas d'un grande utilité. Ce n'est donc pas celle que vous allez implémenter, mais il est toujours intéressant de savoir qu'une telle méthode existe.++La méthode que vous allez implémenter consiste en du brute force.++>**Qu'est-ce que le brute force ?**  Pour faire simple, cela consiste à essayer toutes les combinaisons possibles. Dans notre cas, cela revient à essayer 26 possibilités, puisqu'il y a 26 lettres dans l'alphabet.++Vous allez donc implémenter la fonction ```breakCaesar(msg)```. Elle prend en paramètre une chaine de caractère (chiffrée) et ne renvoie rien. Son but va être d'afficher toutes les possibilités de déchiffrement du message. C'est à dire, à appliquer ```charCaesar(c, d)``` avec différentes valeurs de décalage. Voici un exemple de ce qu'elle devrait afficher pour ```breakCaesar("Rovvy Gybvn")```:++```py+Spwwz Hzcwo+Tqxxa Iadxp+Uryyb Jbeyq+Vszzc Kcfzr+Wtaad Ldgas+Xubbe Mehbt+Yvccf Nficu+Zwddg Ogjdv+Axeeh Phkew+Byffi Qilfx+Czggj Rjmgy+Dahhk Sknhz+Ebiil Tloia+Fcjjm Umpjb+Gdkkn Vnqkc+Hello World     # message déchiffré !+Ifmmp Xpsme+Jgnnq Yqtnf+Khoor Zruog+Lipps Asvph+Mjqqt Btwqi+Nkrru Cuxrj+Olssv Dvysk+Pmttw Ewztl+Qnuux Fxaum+Rovvy Gybvn+```++Vous pouvez tout à fait améliorer l'affichage pour que cela soit davantage lisible !++La fonction ```print()``` va vous être utile. Elle permet d'afficher ce qu'on lui donne en paramètre (une chaîne de caractère, un nombre, une liste...). Par exemple :++```py+>>> s = "Hello World"+>>>print(s)+Hello World+>>> print("Bonjour !")+Bonjour !+>>> print(42)+42+>>> print() # sans argument, print() affiche uniquement un retour à la ligne++>>> +# N'hésitez pas à essayer de votre côté ! +```++### Challenge++Essaye de décrypter ce message chiffré avec le chiffre de César !++```none+C'RXV UV XCRTV T'VJK CR MZV+```++# **Le chiffre de Vigenère**++_Prérequis : avoir fini la partie sur le chiffre de César_++## Un peu d'histoire++---+_[insert] history fact here..._++Le chiffre de Vigenère est une méthode de chiffrement par substitution imaginée au XVIe siècle par Blaise de Vigenère (ou peut-être pas, mais la méthode a néanmoins le nom de Vigenère). Le général prussien Friedrich Kasiski publie en 1863 une méthode permettant de casser ce chiffre.++## Principe du chiffre de Vigenère++---+Cette méthode de chiffrement est assez similaire au chiffre de César que vous avez implémentée précedemment. La différence notable est que, pour Vigenère, on applique à chaque lettre du message un décalage différent. Celui-ci dépendant d'une clé donnée au préalable, correspondant à une chaîne de caractères.++De la clé, on en déduit ensuite les décalages successifs à appliquer (on considère que a est la "0e" lettre de l'alphabet). Exemple avec la clé **"clef"** :++- **c** est la 2e lettre de l'alphabet, le décalage correspond ici à 2+- **l** est la 11e lettre de l'alphabet, ici ce sera 11+- **e** est la 4e lettre de l'alphabet, ici ce sera 4+- **f** est la 5e lettre de l'alphabet, ici ce sera 5++Si la clé est plus courte que le message, celle-ci sera répétée autant de fois que nécessaire. Voici un exemple avec la clé **"clef"** :++```none+Message :           Comment est votre blanquette ?+Clé :               clefclefclefclefclefclefclefcl      ++Message chiffré :   Ezqrgyx gdx xzxwg fqcyuzgexj ?+```++## À vos claviers++---+Pour implémenter le chiffre de Vigenère, il va être plus simple de diviser le problème en sous-problèmes. Vous aurez également besoin de la fonction `letterCaesar(l, d)` réalisée dans la partie sur le chiffre de César.++### La fonction ```keyToOffset(k)```++Cette fonction a pour but de convertir la clé en une liste de décalages. Elle prend en paramètre `k` la clé, qui correspond à une chaîne de caractères. Elle retourne une liste de la longueur de la clé contenant les décalages correspondant à chaque lettre de la clé.++### La fonction ```textVigenere(t, k)```++Cette fonction va chiffrer le texte donné à l'aide du chiffre du Vigenère. Elle prend en paramètre `t`, une chaîne de caractères, qui est le message à dissimuler. L'autre paramètre `k`, est aussi une chaîne de caractères et correspond à la clé.++## Annexe++### Sources++- "La cryptographie militaire", Auguste Kerchkhoffs, 1883+- [Wikipedia: Chiffre de Vigenère](https://fr.wikipedia.org/wiki/Chiffre_de_Vigen%C3%A8re)+- [haltode.fr: Chiffre de Vigenère](https://haltode.fr/algo/chiffrement/chiffre_vigenere.html)++# **La machine Enigma**++>Prérequis : maîtrise basique des classes et de l'opérateur modulo++## **Culture générale**++Tu en as peut-être déjà entendu parler, Enigma est une machine de cryptologie mise au point et utilisée par les allemands pendant la seconde guerre mondiale. Son fonctionnement est déchiffré par le mathématicien Alan Turing, qui est aujourd'hui considéré comme le père de l'informatique moderne.++## **Mais comment fontionne Enigma ?**++### 1. Les rotors++La machine Enigma est composée de 3 parties mobiles appelées "rotors" (visibles sur la photo ci-dessous).+Ces rotors associent une lettre de l'alphabet à une autre. Les trois rotors sont connectés les uns aux autres. Imaginons que l'on donne un **A** au premier rotor, celui-ci pourrait par exemple le transformer en **F**. Le second rotor transforme le **F** en **O** et le troisième transforme le **O** en **E**. *Note ici que les rotors n'appliquent pas un chiffre de César, si **A** devient **F** avec le premier rotor, cela ne veut pas dire que **B** deviendra **G**.*++![Machine Enigma](imgs/enigma.jpeg "Une machine Enigma")++En code, on peut représenter un rotor par une chaîne de 26 caractères.++| Alphabet | ABCDEFGHIJKLMNOPQRSTUVWXYZ |+|---|---|+| Rotor 1 | **EKMFLGDQVZNTOWYHXUSPAIBRCJ** |++>Ici, on peut comprendre que le rotor 1 donnera **E** en sortie pour un **A** en entrée, un **K** pour un **B**, etc... (voir le schéma suivant)++Dernière chose, afin de changer l'état de la machine et de rendre plus complexe le déchiffrement, les rotors peuvent tourner d'un 26ième de tour. Quand cela se produit, les lettres transformées par le rotor changent. Si l'on tourne d'un cran le rotor 1 défini au dessus, le fil dans le rotor qui reliait **A** à **E** reliera désormais **B** à **F**. De la même manière, le fil qui reliait **B** à **K** reliera désormais **C** à **L**, etc...++Puisque cela serait trop simple de tourner les 3 rotors à chaque fois, les cryptologues allemands ont mis au point le système suivant : Pour chaque lettre tapée, le rotor 1 tourne d'un cran. Le rotor 2 tourne lui d'un cran quand le rotor 1 a fait un tour complet (c'est-à-dire toutes les 26 lettres tapées), et le rotor 3 tourne d'un cran à chaque tour complet du rotor 2 (toutes les 676 lettres tapées).++### 2. Le réflecteur++Après avoir fait passer la lettre dans les 3 rotors, on la passe dans une pièce appelée le *réflecteur*. Le réflecteur est une partie similaire à un rotor, car il associe une lettre à une autre, mais reste fixe sans tourner. Enfin, on fini par renvoyer la lettre dans les rotors en sens inverse, et le tour est joué !++### 3. Le tableau de permutations++Comme si cela n'était pas déjà assez compliqué, on rajoute une couche avec le **tableau de permutations**. Le fonctionnement de celui-ci est très simple. Il s'agit simplement de brancher des lettres 2 par 2 pour échanger leur place (on peut échanger comme cela jusqu'à 10 paires de lettres). On branche ce tableau avant le système de rotor. Par exemple, si l'on échange les lettres **A** et **O**, alors chaque **A** tapé par l'opérateur de la machine deviendra un **O** pour le système des rotors, et chaque **A** "renvoyé" par ce dernier sera un **O** pour l'opérateur (et vice-versa, le **O** devient un **A**).++Schéma de fonctionnement d'Enigma++!["schéma fonctionnement"](imgs/enigma_scheme.jpg "Schéma de fonctionnement")

+|title|date|+|---|---|+|TP Cryptologie|2021|++|authors|+|---|+|Clarisse 'Nyota' BLANCO|+|Dorian 'Renji' PÉRON|++# **Le chiffre de César**++_Prérequis : la table ASCII, modulo_++## Un peu d'histoire++---+Ce moyen de chiffrement doit son nom à Jules César, célèbre homme d'état romain. Il aurait utilisé pour certaines de ses communications secrètes, militaires notamment, un chiffrement par substitution. Celui-ci utilisant un décalage d'une valeur trois.++## Qu'est-ce qu'un chiffrement par substitution ?++---+Pour faire simple, cette méthode consiste à substituer la valeur d'une lettre par une lettre, un chiffre ou autre. Dans le cas du chiffrement de César, on substitue une lettre par une autre lettre. Par exemple, si l'on décide d'effectuer un décalage de trois, voici comment la valeur de chaque lettre va évoluer :++![Image not loading](imgs/shifting.jpg)++Voilà comment cela va se répercuter sur l'alphabet tout entier :++| |Substitution avec un décalage de 3|+|---|---|+|Alphabet|A B C D E F G H I J K L M N O P Q R S T U V W X Y Z|+|Substitution|D E F G H I J K L M N O P Q R S T U V W X Y Z A B C|++On observe donc que A (première lettre de l'alphabet) sera encodée par D (troisième lettre de l'alphabet), que B sera encodée par E, que C par F, etc. On remarque que X sera codé par A, Y par B et Z par C. Si le chiffre donné pour le décalage fait dépasser de l'alphabet, on revient au début.++Par exemple, Z est la 26ème  lettre de l'alphabet. Si l'on applique un décalage de deux, on a alors : 26 + 3 = 29. C'est plus qu'il n'y a de lettres dans l'alphabet. Pour revenir au début, il n'y a qu'à soustraire le nombre total de lettres dans l'alphabet : 29 - 26 = 3. La troisième lettre de l'alphabet est C. Z est donc codé par C.++D'autres exemples:++>Décalage de trois : **Girls Can Code!** devient **Jluov Fdq Frgh!**++>Décalage de dix : **Hello World!** devient **Rovvy Gybvn!**++Voilà donc le principe de base du chiffrement de César.++## Place au code++---+Pour implémenter le chiffre de César, il va être plus simple de diviser le problème en deux parties. On peut en effet se dire que dans un premier temps, on va implémenter le chiffre de César pour qu'il ne soit appliqué que sur une lettre, puis ensuite appliquer cela à une chaîne de caractères. Pour l'instant, vous pouvez ne prendre en compte que les lettres majuscules ou minuscules si cela vous aide.++Ainsi, il va falloir implémenter les fonctions ```letterCaesar(l, d)``` et ```textCaesar(s, d)```.++### La fonction ```letterCaesar(l, d)```++Cette fonction va se charger d'appliquer le chiffre de César à seulement une lettre, elle va renvoyer un caractère. Elle prend en paramètre ```l``` qui correspond à la lettre sur laquelle on va appliquer le chiffrement, c'est un caractèrer. Quant au paramètre ```d```, il s'agit du décalage qui va être appliqué, c'est un nombre entier.+>**Bonus:** essayez de gérer les majuscules, minuscules ainsi que la ponctuation.++### La fonction ```textCaesar(t, d)```++Cette fonction va se charger d'appliquer le chiffre de César sur une chaîne de caractères, elle va renvoyer une chaîne de caractères. Elle prend en paramètre ```t``` qui correspond à une chaîne de caractères que l'on souhaite chiffrer. Elle prend également un autre paramètre ```d``` qui correspond au décalage qui doit être appliqué, c'est un nombre entier.++>**Tips :** pensez à prendre en compte les espaces, vous pouvez également utiliser des modulos si vous savez ce que c'est (en python, cela correspond à ```%```).++## Quelques fonctions et notions utiles++---++```py+# L'opérateur + permet, quand il est appliqué à des chaînes de caractères, de concaténer celles-ci. Exemples:++>>> 'Hello' + 'World'+'HelloWorld'+>>> 'O' + 'K'+'OK'+++# La fonction len() permet de connaître la longueur d'une chaîne de caractère.++>>> len('Hello World')+11+>>> s = 'ABCD'+>>> len(s)+4+++# Les fonctions ord() et chr() permettent de transformer un caractère en son code ASCII et vice-versa.++>>> ord('A')+65+>>> ord('C')+67+>>> chr(65)+'A'+++# La méthode upper() permet de tranformer une chaîne de caractères en majuscules.++>>> s = 'hello World'+>>> s.upper()+'HELLO WORLD'+>>> 'a'.upper()+'A'++# La méthode isalpha() permet de déterminer si un caractère est une lettre ou non.++>>> c = '!'+>>> c.isalpha()+False+>>> c = 'a'+>>> c.isalpha()+True+++# La méthode isupper() permet de savoir si un caractère est une majuscule ou non.++>>> c = 'G'+>>> c.isupper()+True+>>> c = "HELLO"+>>> c.isupper()+True+>>> c = 'g'+>>> c.isupper()+False+```++## Déchiffrer un message++---+Pour déchiffrer un message il suffit d'utiliser la clé inverse à celle utilisée pour chiffre. Par exemple:++```py+msg = stringCaesar("Hello World", 10)   # chiffre "Hello World", va donner "Rovvy Gybvn"+stringCaesar(msg, -10)                  # déchiffre msg, va donner "Hello World"+```++Dans un premier temps, testez avec votre code pour observer le résultat obtenu. Puis, adaptez votre code pour prendre en compte les décalages négatifs.++## Casser le chiffre de César++---+Il existe plusieurs méthodes pour casser le chiffre de César. On peut par exemple faire une analyse fréquentielle qui va compter la proportion de chaque lettre dans le message chiffré et comparer par rapport à la fréquence connue des lettres dans la langue du message. En Français, à titre d'exemple, la lettre 'e' est la plus fréquente, ainsi la lettre la plus fréquente du message chiffré doit sans doute correspondre à un 'e'. Cette méthode est très efficace sur les messages longs, le problème est donc que sur les messages dits courts, elle ne sera pas d'un grande utilité. Ce n'est donc pas celle que vous allez implémenter, mais il est toujours intéressant de savoir qu'une telle méthode existe.++La méthode que vous allez implémenter consiste en du brute force.++>**Qu'est-ce que le brute force ?**  Pour faire simple, cela consiste à essayer toutes les combinaisons possibles. Dans notre cas, cela revient à essayer 26 possibilités, puisqu'il y a 26 lettres dans l'alphabet.++Vous allez donc implémenter la fonction ```breakCaesar(msg)```. Elle prend en paramètre une chaine de caractère (chiffrée) et ne renvoie rien. Son but va être d'afficher toutes les possibilités de déchiffrement du message. C'est à dire, à appliquer ```charCaesar(c, d)``` avec différentes valeurs de décalage. Voici un exemple de ce qu'elle devrait afficher pour ```breakCaesar("Rovvy Gybvn")```:++```py+Spwwz Hzcwo+Tqxxa Iadxp+Uryyb Jbeyq+Vszzc Kcfzr+Wtaad Ldgas+Xubbe Mehbt+Yvccf Nficu+Zwddg Ogjdv+Axeeh Phkew+Byffi Qilfx+Czggj Rjmgy+Dahhk Sknhz+Ebiil Tloia+Fcjjm Umpjb+Gdkkn Vnqkc+Hello World     # message déchiffré !+Ifmmp Xpsme+Jgnnq Yqtnf+Khoor Zruog+Lipps Asvph+Mjqqt Btwqi+Nkrru Cuxrj+Olssv Dvysk+Pmttw Ewztl+Qnuux Fxaum+Rovvy Gybvn+```++Vous pouvez tout à fait améliorer l'affichage pour que cela soit davantage lisible !++La fonction ```print()``` va vous être utile. Elle permet d'afficher ce qu'on lui donne en paramètre (une chaîne de caractère, un nombre, une liste...). Par exemple :++```py+>>> s = "Hello World"+>>>print(s)+Hello World+>>> print("Bonjour !")+Bonjour !+>>> print(42)+42+>>> print() # sans argument, print() affiche uniquement un retour à la ligne++>>> +# N'hésitez pas à essayer de votre côté ! +```++### Challenge++Essaye de décrypter ce message chiffré avec le chiffre de César !++```none+C'RXV UV XCRTV T'VJK CR MZV+```++# **Le chiffre de Vigenère**++_Prérequis : avoir fini la partie sur le chiffre de César_++## Un peu d'histoire++---+_[insert] history fact here..._++Le chiffre de Vigenère est une méthode de chiffrement par substitution imaginée au XVIe siècle par Blaise de Vigenère (ou peut-être pas, mais la méthode a néanmoins le nom de Vigenère). Le général prussien Friedrich Kasiski publie en 1863 une méthode permettant de casser ce chiffre.++## Principe du chiffre de Vigenère++---+Cette méthode de chiffrement est assez similaire au chiffre de César que vous avez implémentée précedemment. La différence notable est que, pour Vigenère, on applique à chaque lettre du message un décalage différent. Celui-ci dépendant d'une clé donnée au préalable, correspondant à une chaîne de caractères.++De la clé, on en déduit ensuite les décalages successifs à appliquer (on considère que a est la "0e" lettre de l'alphabet). Exemple avec la clé **"clef"** :++- **c** est la 2e lettre de l'alphabet, le décalage correspond ici à 2+- **l** est la 11e lettre de l'alphabet, ici ce sera 11+- **e** est la 4e lettre de l'alphabet, ici ce sera 4+- **f** est la 5e lettre de l'alphabet, ici ce sera 5++Si la clé est plus courte que le message, celle-ci sera répétée autant de fois que nécessaire. Voici un exemple avec la clé **"clef"** :++```none+Message :           Comment est votre blanquette ?+Clé :               clefclefclefclefclefclefclefcl      ++Message chiffré :   Ezqrgyx gdx xzxwg fqcyuzgexj ?+```++## À vos claviers++---+Pour implémenter le chiffre de Vigenère, il va être plus simple de diviser le problème en sous-problèmes. Vous aurez également besoin de la fonction `letterCaesar(l, d)` réalisée dans la partie sur le chiffre de César.++### La fonction ```keyToOffset(k)```++Cette fonction a pour but de convertir la clé en une liste de décalages. Elle prend en paramètre `k` la clé, qui correspond à une chaîne de caractères. Elle retourne une liste de la longueur de la clé contenant les décalages correspondant à chaque lettre de la clé.++### La fonction ```textVigenere(t, k)```++Cette fonction va chiffrer le texte donné à l'aide du chiffre du Vigenère. Elle prend en paramètre `t`, une chaîne de caractères, qui est le message à dissimuler. L'autre paramètre `k`, est aussi une chaîne de caractères et correspond à la clé.++## Annexe++### Sources++- "La cryptographie militaire", Auguste Kerchkhoffs, 1883+- [Wikipedia: Chiffre de Vigenère](https://fr.wikipedia.org/wiki/Chiffre_de_Vigen%C3%A8re)+- [haltode.fr: Chiffre de Vigenère](https://haltode.fr/algo/chiffrement/chiffre_vigenere.html)++# **La machine Enigma**++>Prérequis : maîtrise basique des classes et de l'opérateur modulo++## **Culture générale**++Tu en as peut-être déjà entendu parler, Enigma est une machine de cryptologie mise au point et utilisée par les allemands pendant la seconde guerre mondiale. Son fonctionnement est déchiffré par le mathématicien Alan Turing, qui est aujourd'hui considéré comme le père de l'informatique moderne.++## **Mais comment fontionne Enigma ?**++### 1. Les rotors++La machine Enigma est composée de 3 parties mobiles appelées "rotors" (visibles sur la photo ci-dessous).+Ces rotors associent une lettre de l'alphabet à une autre. Les trois rotors sont connectés les uns aux autres. Imaginons que l'on donne un **A** au premier rotor, celui-ci pourrait par exemple le transformer en **F**. Le second rotor transforme le **F** en **O** et le troisième transforme le **O** en **E**. *Note ici que les rotors n'appliquent pas un chiffre de César, si **A** devient **F** avec le premier rotor, cela ne veut pas dire que **B** deviendra **G**.*++![Machine Enigma](imgs/enigma.jpeg "Une machine Enigma")++En code, on peut représenter un rotor par une chaîne de 26 caractères.++| Alphabet | ABCDEFGHIJKLMNOPQRSTUVWXYZ |+|---|---|+| Rotor 1 | **EKMFLGDQVZNTOWYHXUSPAIBRCJ** |++>Ici, on peut comprendre que le rotor 1 donnera **E** en sortie pour un **A** en entrée, un **K** pour un **B**, etc... (voir le schéma suivant)++Dernière chose, afin de changer l'état de la machine et de rendre plus complexe le déchiffrement, les rotors peuvent tourner d'un 26ième de tour. Quand cela se produit, les lettres transformées par le rotor changent. Si l'on tourne d'un cran le rotor 1 défini au dessus, le fil dans le rotor qui reliait **A** à **E** reliera désormais **B** à **F**. De la même manière, le fil qui reliait **B** à **K** reliera désormais **C** à **L**, etc...++Puisque cela serait trop simple de tourner les 3 rotors à chaque fois, les cryptologues allemands ont mis au point le système suivant : Pour chaque lettre tapée, le rotor 1 tourne d'un cran. Le rotor 2 tourne lui d'un cran quand le rotor 1 a fait un tour complet (c'est-à-dire toutes les 26 lettres tapées), et le rotor 3 tourne d'un cran à chaque tour complet du rotor 2 (toutes les 676 lettres tapées).++### 2. Le réflecteur++Après avoir fait passer la lettre dans les 3 rotors, on la passe dans une pièce appelée le *réflecteur*. Le réflecteur est une partie similaire à un rotor, car il associe une lettre à une autre, mais reste fixe sans tourner. Enfin, on fini par renvoyer la lettre dans les rotors en sens inverse, et le tour est joué !++### 3. Le tableau de permutations++Comme si cela n'était pas déjà assez compliqué, on rajoute une couche avec le **tableau de permutations**. Le fonctionnement de celui-ci est très simple. Il s'agit simplement de brancher des lettres 2 par 2 pour échanger leur place (on peut échanger comme cela jusqu'à 10 paires de lettres). On branche ce tableau avant le système de rotor. Par exemple, si l'on échange les lettres **A** et **O**, alors chaque **A** tapé par l'opérateur de la machine deviendra un **O** pour le système des rotors, et chaque **A** "renvoyé" par ce dernier sera un **O** pour l'opérateur (et vice-versa, le **O** devient un **A**).++Schéma de fonctionnement d'Enigma++!["schéma fonctionnement"](imgs/enigma_scheme.jpg "Schéma de fonctionnement")++>Si ces explications manquent de clarté, voici [un site très pratique pour visualiser le chemin d'une lettre dans le système](https://observablehq.com/@tmcw/enigma-machine)++### 4. Et pour décoder un message ?++Tu viens d'apprendre le fonctionnement général de la machine Enigma, mais une question persiste : Avec un système aussi complexe, comment fait-on pour décoder un message crypté avec une machine Enigma ? La réponse est sûrement plus simple qu'il n'y paraît : Il suffit de taper le message chiffré sur une machine Enigma qui a les mêmes paramètres initiaux que pour encoder le message ! En effet, prenons le message "GirlsCanCode" et imaginons que tous les rotors soient sur le cran 0 au début du message. Taper **G** sur la machine donnera une lettre différente, peut-être un **V**. Mais de la même manière, si l'on avait tapé **V**, on aurait obtenu **G**, car le chemin de la lettre dans la machine est le même, seulement il est parcouru à l'envers.++## **Exercices**++À ton tour de créer ton propre programme Enigma !++> Afin d'implémenter notre propre machine Enigma, nous utiliserons une classe qui nous sera utile pour sauvegarder l'état actuel des rotors.++Voici le squelette du code:++```py+class Enigma:+    def __init__(self, r1, r2, r3, ref):+        """+        Initialise la machine avec les rotors et le réflecteur donnés+        Appelé par Enigma(...)+        r1 : rotor1+        r2 : rotor2+        r3 : rotor3+        ref : reflecteur+        """+        self.r1 = r1+        self.r2 = r2+        self.r3 = r3+        self.ref = ref+        +        # on initialise le décalage des rotors à 0+        self.x1 = 0+        self.x2 = 0+        self.x3 = 0+    +    def reset_rotors(self):+        # on réinitialise le décalage des rotors à 0+        self.x1 = 0+        self.x2 = 0+        self.x3 = 0+    +    def encode_letter(self, letter):+        pass # À toi de jouer !++    +    def encode_message(self, msg):+        pass # À toi de jouer !++# Exemples++# on déclare notre variable Enigma (avec les rotors définis ci-dessous)+# état initial: tous les décalages à 0+>>> en = Enigma(rotor_I, rotor_II, rotor_III, reflector_A)++>>> en.encode('A')+'N' +# Etat interne des rotors après opération: x1 = 1, x2 = 0, x3 = 0+```++Voici également 2 simples fonctions permettant de trouver le nombre d'une lettre dans l'alphabet (en partant de `0`), et vice-versa:++```py+def letter_to_number(letter):+    """+    Donne la position d'une lettre dans l'alphabet+    """+    letter = letter.upper() # on transforme la lettre en majuscule+    return ord(letter) - ord('A') ++def number_to_letter(number):+    """+    Donne la lettre majuscule correspondante au nombre donné+    """+    return chr(number + ord('A'))++# Examples+>>> letter_to_number('A')+0+>>> letter_to_number('z')+25+++>>> number_to_letter(0)+A+>>> number_to_letter(23)+X+```++Enfin, voici des rotors et réflecteurs qui ont réellement été utilisés pendant la seconde guerre mondiale:++```py+rotor_I = "EKMFLGDQVZNTOWYHXUSPAIBRCJ"+rotor_II = "AJDKSIRUXBLHWTMCQGZNPYFVOE"+rotor_III = "BDFHJLCPRTXVZNYEIWGAKMUSQO"++reflector_A = "EJMZALYXVBWFCRQUONTSPIKHGD"+reflector_B = "YRUHQSLDPXNGOKMIEBFZCWVJAT"