ajout de tous les cours et TP préparés cet été

Sécurité/exemples/chiffrement_ECB.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Jan  8 15:27:05 2021
+
+@author: pjoulaud
+"""
+from numpy.random import permutation
+# Pour créer des permutations aléatoirement
+
+class ECB:
+    """
+    Classe dont les instances sont des cryptosystèmes dépendant de la donnée de leur clé
+    sous la forme d'une permutation
+    """
+    def __init__(self, taille = None, images = None):
+        """
+        Un cryptosystème ECB est défini par la donnée d'une permutation
+        Une permutation a pour attributs sa taille et la liste de ses images.
+        Un des deux doit être donné au moment de l'instanciation.
+        Une Permutation est si besoin créée aléatoirement en utilisant la fonction permutation
+        du module numpy.random
+        
+        >>> ECB(images = [1,0,2]).images
+        [1, 0, 2]
+        """
+        # si les images ne sont pas données, on les tire aléatoirement
+        if images :
+            liste_reference = [i for i in range(len(images))]
+            images_ordonnees = images[:]
+            images_ordonnees.sort()
+            #print(f"liste_reference {liste_reference}-images_ordonnees {images_ordonnees}")
+            if images_ordonnees==liste_reference:
+                self.images = images
+        else :
+            self.images = list(permutation(range(taille)))
+        
+    def __repr__(self):
+        """
+        On représente les images de la permutation :
+
+        >>> ECB(images=[0, 3, 2, 4, 1])
+        0 3 2 4 1
+        """
+        return " ".join([str(image) for image in self.images])
+    
+    def __invert__(self) :
+        """
+        Permet d'obtenir la permutation réciproque de self avec ~
+
+        >>> mon_ecb = ECB(images = [1,3,0,2])
+        >>> mon_ecb
+        1 3 0 2
+        >>> ~mon_ecb
+        2 0 3 1
+        """ 
+        ma_liste = []
+        for i in range(len(self.images)):
+            ma_liste.append(self.images.index(i))
+        mon_ecb = ECB(images=ma_liste)
+        return mon_ecb
+
+    @property
+    def taille(self):
+        """
+        >>> ECB(6).taille
+        6
+        """
+        # si la taille n'est pas donnée, c'est la longueur de la liste des images
+        return len(self.images)
+    
+    def permute(self, une_liste):
+        """
+        Permute les éléments d'une liste donnée en argument 
+        Si xs = [xs[0], xs[1], xs[2],...] et si p est une permutation alors  
+        mon_ecb.permute(xs) = [xs[p(0)], xs[p(1)], xs[p(2)],...] 
+        
+        >>> mon_ecb = ECB(images=[0, 3, 2, 4, 1])
+        >>> ma_liste = ['a', 'b', 'c', 'd', 'e']
+        >>> mon_ecb.permute(ma_liste)
+        ['a', 'd', 'c', 'e', 'b']
+        """
+        if len(une_liste)>=self.taille:
+            return [une_liste[i] for i in self.images]
+        
+    def chaine2texte(self, une_chaine):
+        """
+        Prend une chaine de caractères uniquement composée de 0 et de 1
+        Les cryptosystèmes manipulent des chaines de bits mais les humains veulent du texte
+        Cette méthode permet de transformer une trame de caractères codés sur un octet 
+        en la chaîne de caractères correspondante.
+
+        >>> mon_ecb = ECB(images=[0, 3, 2, 4, 1])
+        >>> mon_ecb.chaine2texte('11101001')
+        'é'
+        >>> mon_ecb.chaine2texte('111010011110100111101001')
+        'ééé'
+
+        À comparer avec :
+
+        >>> chr(0b11101001)
+        'é'
+        """
+        ma_chaine = ''
+        #car_a_completer = len(une_chaine)%8
+        #if  car_a_completer!=0:
+        #    une_chaine = '0'*(8-car_a_completer)+une_chaine
+        for i in range(len(une_chaine)//8):
+            ma_chaine += chr(int(une_chaine[8*i:8*(i+1)],2))
+        return ma_chaine
+        
+    def texte2chaine(self, une_chaine):
+        """
+        On transforme une instance de Texte en la chaîne caractères uniquement composée de 0 et de 1.
+        
+        >>> mon_ecb = ECB(images=[0, 3, 2, 4, 1])
+        >>> mon_ecb.texte2chaine('ab')
+        '0110000101100010'
+        >>> mon_ecb.chaine2texte(mon_ecb.texte2chaine('azerty'))
+        'azerty'
+        """
+        while len(une_chaine)%len(self.images) != 0:
+            une_chaine += ' '
+        ma_chaine = ''
+        for i in une_chaine :
+            for j in "{:08b}".format(ord(i)):
+                ma_chaine += j     
+        return ma_chaine
+    
+    def decoupe_en_blocs(self, les_caracteres):
+        """
+        Prend une chaîne de caractères et la transforme en chaînes de caractères de
+        longueur celle de la permutation en complétant éventuellement par des '0'.
+        Méthode à usage interne facilitant l'écriture de la fonction chiffre
+
+        >>> mon_ecb = ECB(images=[1,0,3,2])                                                                                                                                       
+        >>> mon_ecb.decoupe_en_blocs('123456789123456789')                                                                                                              
+        ['12345', '67891', '23456', '78900']
+        """
+        ma_liste = []
+        car_a_completer = len(les_caracteres)%self.taille
+        if  car_a_completer!=0:
+            les_caracteres = '0'*(self.taille-car_a_completer) + les_caracteres
+        car_a_completer = len(les_caracteres)%8
+        if  car_a_completer!=0:
+            les_caracteres = '0'*(8-car_a_completer) + les_caracteres
+        nb_car_par_elem = len(les_caracteres)//self.taille
+        for i in range(self.taille):
+            ma_liste.append(les_caracteres[i*nb_car_par_elem:(i+1)*nb_car_par_elem])
+        return ma_liste
+    
+    def permute(self, les_caracteres):
+        """
+        Renvoie la liste des permutations des blocs de longueur celle de la permutation
+        construits à partir d'une chaîne de caracteres.
+
+        >>> mon_ecb = ECB(images=[1,0,3,2])                                                                                                                                          
+        >>> mon_ecb.permute('123456789123456789')
+        '67891123457890023456'
+        """
+        ma_liste_de_chaine = self.decoupe_en_blocs(les_caracteres)
+        #print(f"{ma_liste_de_chaine} toto")
+        ma_liste_de_chaine2 = []
+        for indice in self.images :
+            #print(f"{une_chaine}")
+            #ma_chaine = Chaine(self.cle.permute(une_chaine.entiers))
+            #print(f"{ma_chaine}")
+            ma_liste_de_chaine2.append(ma_liste_de_chaine[indice])
+        #print(f"{ma_liste_de_chaine} - {ma_liste_de_chaine2}")
+        return "".join(ma_liste_de_chaine2)
+    
+    def chiffre(self, message):
+        """
+        Retourne le message chiffré sous forme de chaîne de caracères.
+        Utilise les sous-méthodes précédentes.
+
+        >>> mon_ecb = ECB(images=[0, 1, 3, 4, 2])
+        >>> chaine_0_1 = mon_ecb.texte2chaine('hello world')
+        >>> chaine_0_1_code = mon_ecb.permute(chaine_0_1)
+        >>> message_code = mon_ecb.chaine2texte(chaine_0_1_code)
+        
+        """
+        chaine_0_1 = mon_ecb.texte2chaine(message)
+        #print(f"{chaine_0_1}")
+        chaine_0_1_code = mon_ecb.permute(chaine_0_1)        
+        #print(f"{chaine_0_1_code}")
+        return mon_ecb.chaine2texte(chaine_0_1_code)
+    
+    def dechiffre(self, message_code):
+        ecb_inverse = ~self
+        chaine_0_1 = ecb_inverse.texte2chaine(message_code)
+        print(f"0 : {chaine_0_1}")
+        chaine_0_1_code = ecb_inverse.permute(chaine_0_1)        
+        print(f"1 : {chaine_0_1_code}")
+        
+        return ecb_inverse.chaine2texte(chaine_0_1_code)
+        
+
+#mon_ecb = ECB(6)
+#print(mon_ecb)
+#print(mon_ecb.taille)
+import doctest
+doctest.testmod()
+mon_ecb = ECB(25)
+toto = mon_ecb.chiffre("Et si quelquefois, sur les marches d'un palais, sur l'herbe verte d'un fossé, vous vous réveillez, l'ivresse déjà diminuée ou disparue, demandez au vent, à la vague, à l'étoile, à l'oiseau, à l'horloge; à tout ce qui fuit, à tout ce qui gémit, à tout ce qui roule, à tout ce qui chante, à tout ce qui parle, demandez quelle heure il est. Et le vent, la vague, l'étoile, l'oiseau, l'horloge, vous répondront, il est l'heure de s'enivrer ; pour ne pas être les esclaves martyrisés du temps, enivrez-vous, enivrez-vous sans cesse de vin, de poésie, de vertu, à votre guise")
+print(toto)
+titi = mon_ecb.dechiffre(toto)
+print(titi)

Sécurité/exemples/chiffrement_rsa.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Feb  3 12:41:14 2021
+
+@author: pjoulaud
+"""
+
+CLE_PRIV_P = 53
+CLE_PRIV_Q = 97
+CLE_PUB_E = 7
+CLE_PUB_N = CLE_PRIV_P * CLE_PRIV_Q
+
+
+def conversion_message_en_nombre(chaine, bloc=3):
+    nombre = ""
+    for i in chaine :
+        nombre += str(ord(i)-ord('A')+1)
+        #print(nombre)
+    while len(nombre)%bloc != 0 :
+        nombre = '0' + nombre
+    return nombre
+
+def chiffrement(chaine_num, bloc=3, e=CLE_PUB_E, n=CLE_PUB_N):
+    code = ""
+    for i in range(len(chaine_num)//bloc):
+        morceau_chaine_num = chaine_num[i*bloc:(i+1)*bloc]
+        #print(morceau_chaine_num)
+        morceau_chaine_num = int(morceau_chaine_num)
+        morceau_chaine_num = morceau_chaine_num**e
+        morceau_chaine_num = morceau_chaine_num%n
+        morceau_chaine_num = str(morceau_chaine_num)
+        code += morceau_chaine_num
+        code += ' '
+    return code[:-1]
+    
+def dechiffrement(chaine_num, bloc=2, e=CLE_PUB_E, n=CLE_PUB_N, p=CLE_PRIV_P, q=CLE_PRIV_Q):
+    nombre = 1
+    while nombre%e != 0 :
+        nombre += (p-1)*(q-1)
+        print(nombre)
+    d = nombre//e
+    liste_num = chaine_num.split(' ')
+    print(liste_num)
+    liste_decod = []
+    for i in liste_num :
+        decode = (int(i)**d) % n
+        liste_decod.append(str(decode))
+    print(liste_decod)
+    chaine_decode = ''.join(liste_decod)
+    print(chaine_decode)
+    message = ""
+    a_completer = len(chaine_decode)%bloc
+    for i in range(a_completer):
+        chaine_decode = '0' + chaine_decode
+    for i in range(len(chaine_decode)//bloc):
+        morceau_chaine_num = int(chaine_decode[i*bloc:(i+1)*bloc])
+        message += chr(morceau_chaine_num+ord('A')-1)
+        print(morceau_chaine_num, ' ',message)
+    return message
+
+ma_chaine_num = conversion_message_en_nombre('BONJOUR')
+print(ma_chaine_num)
+mon_code = chiffrement(ma_chaine_num)
+print(mon_code)
+mon_message = dechiffrement(mon_code)
+print('message : ', mon_message)

Sécurité/exemples/chiffrement_rsa2.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Feb  3 12:41:14 2021
+
+@author: pjoulaud
+"""
+
+BLOC_ASCII = 2
+CLE_PRIV_P = 53
+CLE_PRIV_Q = 97
+CLE_PUB_E = 11
+CLE_PUB_N = CLE_PRIV_P * CLE_PRIV_Q
+
+
+def car_to_fig(chaine : str) -> str:
+    """
+    Transforme une chaine de caractères en une chaine de caractères
+    correspondant à leurs numéros d' ordre.
+    Attention ! Chaque numéro d' ordre est codé sur BLOC_ASCII chiffres
+    Arguments : chaine, chaine à coder de type str
+    Retourne : nombre, une chaine de caractères avec tous les numéros d' ordre
+    >>> car_to_fig('A')
+    '01'
+    >>> car_to_fig('ABZ')
+    '010226'
+    """
+    nombre = ""
+    liste = []
+    for i in chaine :
+        ordre = str(ord(i)-ord('A')+1)
+        while len(ordre)%BLOC_ASCII != 0:
+            ordre = '0'+ordre
+        liste.append(ordre)
+    #print(liste)
+    nombre = "".join(liste)
+    return nombre
+
+def chiffrement(chaine, bloc=3, e=CLE_PUB_E, n=CLE_PUB_N):
+    """
+    Transforme une chaine de caractères en une chaine de caractères
+    correspondant à leurs numéros d' ordre codés.
+    Chaque numéro est séparé par un espace
+    Arguments : chaine, chaine à coder de type str
+    Retourne : nombre, une chaine de caractères avec les numéros codés
+    >>> chiffrement('A')
+    '1689'
+    >>> chiffrement('ABZ')
+    '755 2705'
+    """
+    chaine_num = car_to_fig(chaine)
+    while len(chaine_num)%bloc != 0 :
+        chaine_num = '0'+chaine_num
+    print("code du message initial :\n",chaine_num)
+    liste = []
+    for i in range(len(chaine_num)//bloc):
+        morceau_chaine_num = chaine_num[i*bloc:(i+1)*bloc]
+        morceau_chaine_num = int(morceau_chaine_num)
+        morceau_chaine_num = morceau_chaine_num**e
+        morceau_chaine_num = morceau_chaine_num%n
+        liste.append(str(morceau_chaine_num))
+    code = " ".join(liste)
+    print("code du message chiffre :\n", code)
+    return code
+    
+def dechiffrement(chaine_num, bloc=3, e=CLE_PUB_E, n=CLE_PUB_N, p=CLE_PRIV_P, q=CLE_PRIV_Q):
+    """
+    Transforme une chaine de caractères correspondant à leurs numéros d' ordre
+    codés en message décodé.
+    Arguments : chaine_num, chaine de codes de type str
+    Retourne : message, une chaine de caractères avec le message décodé
+    >>> dechiffrement(chiffrement('A'))
+    'A'
+    >>> dechiffrement(chiffrement('ABZ'))
+    'ABZ'
+    """
+    nombre = 1
+    # PARTIE LA PLUS DIFFICILE
+    # Il faut déterminer e tel que e.d = 1 mod [(p-1)(q-1)]
+    # Mon astuce : On incrémente de (p-1)(q-1) jusqu' à obtenir un nombre
+    # divisible par e
+    while nombre%e != 0 :
+        nombre += (p-1)*(q-1)
+    d = nombre//e
+    liste_num = chaine_num.split(' ')
+    liste_decod = []
+    for i in liste_num :
+        decode = (int(i)**d) % n
+        decode = str(decode)
+        while len(decode)%bloc != 0:
+            decode = '0'+decode
+        liste_decod.append(decode)
+    chaine_decode = ''.join(liste_decod)
+    message = ""
+    while len(chaine_decode)%BLOC_ASCII != 0:
+        chaine_decode = '0' + chaine_decode
+    print("code du message dechiffre : \n",chaine_decode)
+    for i in range(len(chaine_decode)//BLOC_ASCII, 0, -1):
+        morceau_chaine_num = chaine_decode[(i-1)*BLOC_ASCII:i*BLOC_ASCII]
+        morceau_chaine_num = int(morceau_chaine_num)
+        if morceau_chaine_num != 0:
+            message = chr(morceau_chaine_num+ord('A')-1) + message
+    print("Message dechiffre :\n", message)
+    return message
+
+if __name__=='__main__':
+    if (CLE_PRIV_P-1)*(CLE_PRIV_Q-1)%CLE_PUB_E == 0:
+        raise Exception("e n' est pas premier avec (p-1)(q-1)")
+    chaine_depart = 'ABONJOURLESFRANCAISESETLESFRANCAIS'
+    print("chaine de depart : ",chaine_depart)
+    mon_code = chiffrement(chaine_depart, bloc=4)
+    #print("code : ", mon_code)
+    mon_message = dechiffrement(mon_code, bloc=4)
+    print('message : ', mon_message)

Sécurité/exemples/codage_binaire.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Feb  3 10:55:48 2021
+
+@author: pjoulaud
+"""
+
+def codage_binaire(message : str, code : str) -> str:
+    """
+    Fonction qui code un message à l' aide d' une clé. Le message codé resulte 
+    d' un OU exclusif bit à bit
+    Argument : 
+        - message : Message à coder de type str
+        - code : Clé de codage de type str
+    Retourne :
+        - res : Message codé bit à bit
+    >>> codage_binaire(codage_binaire("Hello World!", "toto"), "toto")
+    'Hello World!'
+    """
+    i = 0
+    res = ''
+    for car in message :
+        ord_car = ord(car)^ord(code[i%len(code)])
+        #print(f"car  : {ord(car):08b}\ncode : {ord(code[i%len(code)]):08b}\n   =>  {ord_car:08b} \n")
+        res += chr(ord_car)
+        i += 1
+    return res
+
+#CORPS DE PROGRAMME
+if __name__=='__main__':
+    import doctest
+    doctest.testmod()
+    #message_code = codage_binaire('Hello World', 'toto')
+    #input("Tapez Entree pour continuer")
+    #message_decode = codage_binaire(message_code, 'toto')

Sécurité/exemples/code_cesar.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jan  7 20:03:19 2021
+
+@author: pjoulaud
+"""
+
+def code_cesar(texte, decalage):
+    """
+    Fonction qui code un texte suivant la méthode de césar (chaque lettre est
+    décalé).
+    Arguments ::
+        - texte : message à coder de type str
+        - decalage : indice de décalage de type int
+    Renvoie ::
+        - texte_chiffre : le message codé de type str
+    >>> code_cesar("VENI, VIDI, DICI", 3)
+    YHQL, YLGL, GLFL
+    """
+    texte_chiffre = ""
+    for lettre in texte :
+        if lettre in ('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'):
+            ordre_dans_alphabet = ord(lettre)+decalage-ord('A')
+            texte_chiffre += chr(ordre_dans_alphabet%26+ord('A'))
+        else:
+            texte_chiffre += lettre
+    return texte_chiffre
+
+def code_cesar2(texte, decalage):
+    """
+    Fonction qui code un texte suivant la méthode de césar (chaque lettre est
+    décalé).
+    Variante proposée par C. Veillon
+    Arguments ::
+        - texte : message à coder de type str
+        - decalage : indice de décalage de type int
+    Renvoie ::
+        - texte_chiffre : le message codé de type str
+    >>> code_cesar("VENI, VIDI, DICI", 3)
+    YHQL, YLGL, GLFL
+    """
+    texte_chiffre = ""
+    liste_avec_lettres = []
+    for i in range(65, 91):
+        liste_avec_lettres.append(chr(i))
+    #print(liste_avec_lettres)
+    for lettre in texte :
+        if lettre in liste_avec_lettres:
+            for i in range(len(liste_avec_lettres)):
+                if lettre == liste_avec_lettres[i]:
+                    texte_chiffre += liste_avec_lettres[(i+decalage)%26]
+        else :
+            texte_chiffre += lettre
+    return texte_chiffre
+
+def decode_cesar(texte, decalage):
+    """
+    Fonction qui décode un texte suivant la méthode de césar.
+    Arguments ::
+        - texte : message codé de type str
+        - decalage : indice de décalage de type int
+    Renvoie ::
+        - le message décodé de type str
+    >>> code_cesar("YHQL, YLGL, GLFL", 3)
+    VENI, VIDI, DICI
+    """
+    return code_cesar(texte, -decalage)
+
+if __name__ == '__main__':
+    #ACTION DE CODAGE
+    toto=code_cesar('VENI, VIDI, DICI',3)
+    print("message codé : ", toto)   
+    #ACTION DE DECODAGE
+    toto=decode_cesar(toto,3)
+    print("message décodé : ", toto)   
+
+    #ACTION DE CODAGE
+    toto=code_cesar2('VENI, VIDI, DICI',3)
+    print("message codé (méthode C. Veillon) : ", toto)   
+    #ACTION DE DECODAGE        
+    toto=code_cesar2(toto,-3)
+    print("message décodé (méthode C. Veillon) : ", toto)   

Sécurité/exemples/code_inverse.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jan  7 20:03:19 2021
+
+@author: pjoulaud
+"""
+
+def codage_inverse(texte):
+    """
+    Fonction qui code un texte suivant la méthode de codage inverse
+    (A <=> Z, B <=> Y, C <=> X, ...).
+    Arguments ::
+        - texte : message à coder de type str
+    Renvoie ::
+        - texte_chiffre : le message codé de type str
+    >>> codage_inverse('VENI, VIDI, DICI')
+    FWNS, FSXS, XSYS
+        >>> codage_inverse(codage_inverse('VENI, VIDI, DICI'))
+    VENI, VIDI, DICI
+    """
+    texte_chiffre = ""
+    for lettre in texte :
+        if lettre in ('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'):
+            ordre_dans_alphabet = 26-ord(lettre)-ord('A')
+            texte_chiffre += chr(ordre_dans_alphabet%26+ord('A'))
+        else:
+            texte_chiffre += lettre
+    return texte_chiffre
+
+if __name__ == '__main__':
+    #ACTION DE CODAGE
+    toto=codage_inverse('VENI, VIDI, DICI')
+    print(toto)
+    #ACTION DE CODAGE
+    toto=codage_inverse(toto)
+    print(toto)

Sécurité/exemples/code_par_substitution.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jan  7 20:03:19 2021
+
+@author: pjoulaud
+"""
+from random import randint
+
+def genere_table():
+    """
+    Fonction qui génère aléatoirement une table de correspondance entre lettres
+    Les clés correspondent à chaque lettre de l' alphabet et les valeurs à une
+    autre lettre prise au hasard.
+    Arguments :
+        - Aucun
+    Retourne :
+        - dico_chiffrement de type dict
+    >>> toto = list(genere_table().keys())
+    >>> toto.sort()
+    >>> print(toto)
+    ['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']
+    >>> toto = list(genere_table().values())
+    >>> toto.sort()
+    >>> print(toto)
+    ['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']
+    """
+    dico_chiffrement = {}
+    toutes_les_lettres = ('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')
+    liste_lettres = list(toutes_les_lettres)
+    for lettre in toutes_les_lettres:
+        position = randint(0, len(liste_lettres)-1)
+        lettre_correspondante = liste_lettres[position]
+        dico_chiffrement[lettre] = lettre_correspondante
+        liste_lettres.remove(lettre_correspondante)
+    return dico_chiffrement
+        
+
+def code_par_substitution(texte, table):
+    """
+    Fonction qui code un message grâce à une table de correspondance.
+    Arguments :
+        - texte : Message à coder de type str
+        - table : Table de correspondance de type dict
+    Retourne :
+        - texte_chiffre : Message codé de type str
+    >>> ma_table = {'A': 'H', 'B': 'A', 'C': 'F', 'D': 'M', 'E': 'D', 'F': 'T',\
+    'G': 'Z', 'H': 'W', 'I': 'L', 'J': 'X', 'K': 'G', 'L': 'S', 'M': 'I',\
+    'N': 'V', 'O': 'R', 'P': 'C', 'Q': 'O', 'R': 'E', 'S': 'N', 'T': 'Y',\
+    'U': 'U', 'V': 'K', 'W': 'B', 'X': 'J', 'Y': 'Q', 'Z': 'P'}
+    >>> code_par_substitution("BONJOUR TOUT LE MONDE", ma_table)
+    'ARVXRUE YRUY SD IRVMD'
+    """
+    texte_chiffre = ""
+    for lettre in texte :
+        if lettre in ('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'):
+            texte_chiffre += table[lettre]
+        else:
+            texte_chiffre += lettre
+    return texte_chiffre
+
+def decode_par_substitution(texte, table):
+    """
+    Fonction qui décode un message grâce à une table de correspondance.
+    Arguments :
+        - texte : Message codé de type str
+        - table : Table de correspondance de type dict
+    Retourne :
+        - texte_chiffre : Message décodé de type str
+    >>> ma_table = genere_table()
+    >>> decode_par_substitution(code_par_substitution("BONJOUR TOUT LE MONDE", ma_table), ma_table)
+    'BONJOUR TOUT LE MONDE'
+    """
+    nouvelle_table = {}
+    for cle, valeur in table.items():
+        nouvelle_table[valeur]=cle
+    return code_par_substitution(texte, nouvelle_table)
+
+if __name__=='__main__':
+    import doctest
+    doctest.testmod()
+    #ma_table_chiffrement = genere_table()
+    #print(ma_table_chiffrement)
+    #message_code = code_par_substitution("BONJOUR TOUT LE MONDE", ma_table_chiffrement)
+    #print(message_code)
+    #message_decode = decode_par_substitution(message_code, ma_table_chiffrement)
+    #print(message_decode)

Sécurité/exemples/substitution_polyalphabetique.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Feb 16 12:30:05 2022
+
+@author: pjoulaud
+"""
+
+PREM_CARAC = ord('A') - 1
+DER_CARAC = ord('Z')
+#PREM_CARAC = 32
+#DER_CARAC = 126
+#PREM_CARAC = 0x21
+#DER_CARAC = 0x1f0df
+MODULO = DER_CARAC - PREM_CARAC
+
+def codage_cle_chiffrement(chaine_a_coder, cle):
+    """
+    Fonction de codage par substitution polyalphabetique
+    Arguments :
+        - chaine_a_coder : Message à coder de type str
+        - cle : clé de chiffrement de type str
+    Retourne :
+        - chaine_chiffree : Message codé de type str
+    >>> codage_cle_chiffrement("JE TIENS ENFIN LA GAULE", "SCIENCE")
+    'CH CNSQX XQONB OF ZDDQS'
+    """
+    chaine_chiffree = ""
+    i = 0
+    for car in chaine_a_coder :
+        if car != " ":
+            ord_car = ord(car) - PREM_CARAC
+            ord_cle = ord(cle[i%len(cle)]) - PREM_CARAC
+            sum_ord = ord_car + ord_cle
+            #print(f"car : {car} - ord_car : {ord_car} - ord_cle : {ord_cle} - sum_ord : {sum_ord} - ")
+            if sum_ord <= MODULO :
+                car2 = chr(PREM_CARAC + sum_ord)
+            else :
+                car2 = chr(PREM_CARAC + sum_ord%MODULO)
+            i += 1
+        else :
+            car2 = car
+        chaine_chiffree += car2
+    return chaine_chiffree
+
+def car_to_num(c):
+    return ord(c) - PREM_CARAC
+
+def num_to_car(n):
+    if n <= MODULO :
+        return chr(PREM_CARAC + n)
+    else :
+        return chr(PREM_CARAC + n%MODULO)
+
+def codage_cle_chiffrement2(chaine_a_coder, cle):
+    """
+    Fonction de codage par substitution polyalphabetique - 2e version
+    Passe par deux fonctions (car_to_num et num_to_car) pour convertir
+    de caractères vers valeur numérique et vice-versa.
+    Arguments :
+        - chaine_a_coder : Message à coder de type str
+        - cle : clé de chiffrement de type str
+    Retourne :
+        - chaine_chiffree : Message codé de type str
+    >>> codage_cle_chiffrement2("JE TIENS ENFIN LA GAULE", "SCIENCE")
+    'CH CNSQX XQONB OF ZDDQS'
+    """
+    chaine_chiffree = ""
+    i = 0
+    for car in chaine_a_coder :
+        if car != " ":
+            ord_car = car_to_num(car)
+            ord_cle = car_to_num(cle[i%len(cle)])
+            sum_ord = ord_car + ord_cle
+            #print(f"car : {car} - ord_car : {ord_car} - ord_cle : {ord_cle} - sum_ord : {sum_ord} - ")
+            car2 = num_to_car(sum_ord)
+            i += 1
+        else :
+            car2 = car
+        chaine_chiffree += car2
+    return chaine_chiffree
+
+def decodage_cle_chiffrement(chaine_codee, cle):
+    """
+    Fonction de décodage par substitution polyalphabetique
+    Arguments :
+        - chaine_codee : Message codé de type str
+        - cle : clé de chiffrement de type str
+    Retourne :
+        - chaine_clair : Message décodé de type str
+    >>> decodage_cle_chiffrement(codage_cle_chiffrement("JE TIENS ENFIN LA GAULE", "SCIENCE"), "SCIENCE")
+    'JE TIENS ENFIN LA GAULE'
+    """
+    chaine_clair = ""
+    i = 0
+    for car in chaine_codee :
+        if car != " ":
+            ord_car = ord(car) - PREM_CARAC
+            ord_cle = ord(cle[i%len(cle)]) - PREM_CARAC
+            sum_ord = ord_car - ord_cle + MODULO
+            #print(f"car : {car} - ord_car : {ord_car} - ord_cle : {ord_cle} - sum_ord : {sum_ord} - ")
+            if sum_ord <= MODULO :
+                car2 = chr(PREM_CARAC + sum_ord)
+            else :
+                car2 = chr(PREM_CARAC + sum_ord%MODULO)
+            i += 1
+        else :
+            car2 = car
+        chaine_clair += car2
+    return chaine_clair
+
+#CORPS DE PROGRAMME
+if __name__=='__main__':
+    import doctest
+    doctest.testmod()