Chiffrement affine en Python

Le chiffrement affine est une méthode de chiffrement basée sur les fonctions affines… Mouais !

En d’autres termes, si x est le code d’une lettre sur un alphabet déterminé alors cette dernière sera transformée en une autre lettre dont le code est égal à ax+b mod n (où n est le nombre de caractères de l’alphabet choisi et où a et b sont deux entiers strictement inférieurs à n).

Par exemple, si on considère l’alphabet « ABCDEFGHIJKLMNOPQRSTUVWXYZ » et si on décide d’attribuer le nombre 0 à « A », 1 à « B », … , 25 à « Z », en prenant le chiffrement basé sur les nombres a = 3 et b = 7, la lettre « M » (dont le code est 12) est transformée en la lettre dont le code est $y\equiv3\times12+7\mod26$ soit $y\equiv43\mod26$, donc en la lettre dont le code est y = 17, c’est-à-dire en la lettre « R ».

Pour automatiser le chiffrement d’un mot, il est alors pratique d’utiliser un programme.

Voici un exemple de programme Python qui permet de chiffrer et déchiffrer un message :

# Calcul du pgcd de a et b

def pgcd(a,b):
    while b!=0:
        a,b=b,a%b
    return a

# fonction de chiffrement affine

def chiffrementAffine(a,b,L):
        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"]
        x=alphabet.index(L)
        y=(a*x+b)%26
        return alphabet[y]

# Calcul de l'inverse d'un nombre modulo 26

def inverse(a):
        x=0
        while (a*x%26!=1):
                x=x+1
        return x

# Fonction de déchiffrement

def dechiffrementAffine(a,b,L):
    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"]
    x=alphabet.index(L)
    y=(inverse(a)*(x-b))%26
    return alphabet[y]
                

# Affichage du mot chiffré

def crypt(M,a,b):
    if (pgcd(a,26)==1):
        mot = []
        for i in range(0,len(M)):
                mot.append(chiffrementAffine(a,b,M[i]))
        return "".join(mot)
    else:
        return "Chiffrement impossible. Veuillez choisir un nombre a premier avec 26."

# Affichage du mot déchiffré

def decrypt(M,a,b):
    if (pgcd(a,26)==1):
        mot = []
        for i in range(0,len(M)):
                mot.append(dechiffrementAffine(a,b,M[i]))
        return "".join(mot)
    else:
        return "Déchiffrement impossible. Le nombre a n'est pas premier avec 26."

Une autre variante des deux dernières fonctions est :

# Affichage du mot chiffré

def crypt(M,a,b):
    if (pgcd(a,26)==1):
        mot = [chiffrementAffine(a,b,i) for i in M]
        return "".join(mot)
    else:
        return "Chiffrement impossible. Veuillez choisir un nombre a premier avec 26."

# Affichage du mot déchiffré

def decrypt(M,a,b):
    if (pgcd(a,26)==1):
        mot = [dechiffrementAffine(a,b,i) for i in M]
        return "".join(mot)
    else:
        return "Déchiffrement impossible. Le nombre a n'est pas premier avec 26."

En tapant :

crypt("MATH",3,7)

on demande de chiffrer le mot « MATH » en prenant a = 3 et b = 7.

Le programme nous retourne alors : « RHMC ».

Maintenant, en tapant :

decrypt("RHMC",3,7)

on demande de déchiffrer le message.

Le programme retourne alors : « MATH » (logique !).

Bien entendu, si on prend a = 13, le chiffrement est impossible (car 13 et 26 ne sont pas premiers entre eux) et le programme retourne la phrase :

Chiffrement impossible. Veuillez choisir un nombre a premier avec 26.

Le chiffrement affine était au programme de Spécialité Math en Terminale S en France (exigible pour le bac).